public XElement Transform(XElement report, IReportContext reportContext, IUserContext userContext)
{
if (reportContext == null)
{
throw new ArgumentException("ReportContext not initialized");
}
if (!(_sqlConn.State == ConnectionState.Open))
{
_sqlConn.Open();
}
//get the users userName and look up the preferred language.
SqlCommand cmd = new SqlCommand("SELECT Language from UserConfiguration where UserName='******'", _sqlConn);
SqlDataReader sdr = cmd.ExecuteReader();
sdr.Read();
string language = (string)sdr["Language"];
sdr.Close();
//translate all textbox items (<TextRun><Value>TEXT</Value></TextRun>)
//we will skip expressions (starting with =)
report.Descendants().Where(x => x.Name.LocalName == "Value" && x.Parent.Name.LocalName == "TextRun" && (!x.Value.StartsWith("=")))
.ToList()
.ForEach(x => x.Value = Translate(x.Value, language));
_sqlConn.Close();
return(report);
}
private async Task ExecutePhase(IReportContext context, ReportPhase phase, IScope scope)
{
Logg.Debug(new { op = "start phase", phase });
var agents = context.Agents.Where(_ => _.Phase.HasFlag(phase)).OrderBy(_ => _.Idx).GroupBy(_ => _.Idx).ToArray();
foreach (var grp in agents)
{
if (grp.Count() == 1)
{
await grp.First().Execute(context, phase, scope);
}
else if (grp.All(_ => _.Parallel))
{
var waitgroup = new List <Task>();
foreach (var agent in grp)
{
waitgroup.Add(agent.Execute(context, phase, scope));
}
Task.WaitAll(waitgroup.ToArray());
}
else
{
foreach (var agent in grp)
{
await agent.Execute(context, phase, scope);
}
}
}
Logg.Debug(new { op = "end phase", phase });
}
private void DoBuildHtml(IReportContext context, IScope scope) {
var htmlconfig = new HtmlConfig();
bool standalone = context.Request.Standalone;
if (standalone) {
htmlconfig.DocHeader = RenderXml(context, scope, DocHeader, null, "DocHeader");
}
htmlconfig.Header = RenderXml(context, scope, Header, null, "Header");
htmlconfig.Content = RenderXml(context, scope, Content, null, "Content");
var items = context.Data.arr("items");
IList<ItemXml> xitems = new List<ItemXml>();
if (null != items) {
var i = 0;
foreach (var item in items) {
var itemScope = new Scope(scope);
itemScope["_item"] = item;
itemScope["_idx"] = i;
var xitem = new ItemXml();
xitem.Before = RenderXml(context, itemScope, BeforeItem, item, "BeforeItem");
xitem.Item = RenderXml(context, itemScope, Item, item, "Item");
xitem.After = RenderXml(context, itemScope, AfterItem, item, "AfterItem");
if (null != (xitem.Before ?? xitem.After ?? xitem.Before)) {
xitems.Add(xitem);
}
i++;
}
}
htmlconfig.Items = xitems;
htmlconfig.Footer = RenderXml(context, scope, Footer, null, "Footer");
XElement docfooter = null;
if (standalone) {
htmlconfig.DocFooter = RenderXml(context, scope, DocFooter, null, "DocFooter");
}
var xmlhtml = CompileHtml(context, scope, htmlconfig);
context.Write(xmlhtml.ToString());
}
public override async Task Execute(IReportContext context, ReportPhase phase, IScope scope = null)
{
context.SetHeader("Content-Type","text/html");
context.Write("<textarea>");
context.Write(context.Data.stringify());
context.Write("</textarea>");
}
private void DoStreamRender(IReportContext context, IScope scope)
{
if (context.Request.Standalone)
{
Render(context, scope, DocHeader, null, "DocHeader");
}
Render(context, scope, Header, null, "Header");
Render(context, scope, Content, null, "Content");
var items = context.Data.arr("items");
if (null != items)
{
var i = 0;
foreach (var item in items)
{
var itemScope = new Scope(scope);
itemScope["_item"] = item;
itemScope["_idx"] = i;
Render(context, itemScope, BeforeItem, item, "BeforeItem");
Render(context, itemScope, Item, item, "Item");
Render(context, itemScope, AfterItem, item, "AfterItem");
i++;
}
}
Render(context, scope, Header, null, "Footer");
if (context.Request.Standalone)
{
Render(context, scope, DocFooter, null, "DocFooter");
}
}
public override async Task Execute(IReportContext context, ReportPhase phase, IScope scope = null)
{
context.SetHeader("Content-Type", "text/html");
context.Write("<textarea>");
context.Write(context.Data.stringify());
context.Write("</textarea>");
}
/// <summary>
/// 构造函数
/// </summary>
/// <param name="logger"></param>
/// <param name="serializer"></param>
/// <param name="_ReportContext"></param>
public ReportManager(ILogger logger, ISerializer serializer,
IReportContext iReportContext)
{
m_logger = logger;
m_serializer = serializer;
_iReportContext = iReportContext;
}
private IScope Render(IReportContext context, IScope scope, string templateUri, object item, string templateName, bool cache = false)
{
if (string.IsNullOrWhiteSpace(templateUri))
{
return(null);
}
if (context.IsSet("-render_" + templateName.ToLowerInvariant()))
{
return(null);
}
if (!templateCache.ContainsKey(templateUri))
{
templateCache[templateUri] = Renders.GetRender(templateUri, scope);
}
var template = templateCache[templateUri];
if (null == template)
{
throw new Exception("cannot find template " + templateUri);
}
var ts = scope;
if (cache)
{
ts = new Scope(ts);
ts["store_render"] = true;
ts["no_render"] = true;
ts["render_name"] = templateName;
}
var result = template.Render(context, ts, item);
return(result);
}
public override IScope Render(IReportContext context, IScope scope, object item)
{
scope = scope ?? context.Scope;
Template = Template ?? XmlExtensions.Load(FileName, BxlParserOptions.ExtractSingle);
Xi = Xi ?? new XmlInterpolation {
UseExtensions = true, XmlIncludeProvider = new XmlIncludeProvider {
Container = _container
}
};
IScope ws = null;
if (null == context)
{
ws = scope;
}
else
{
ws = new Scope(context.Data);
ws["data"] = context.Data;
ws["context"] = context;
ws["scope"] = scope;
ws["item"] = item;
ws["reportcode"] = context.Report.Id;
ws["reportname"] = context.Report.Name;
}
var result = Xi.Interpolate(Template, ws);
RemoveDebugInfo(scope, result);
Finalize(context, scope, result);
return(scope);
}
protected virtual void Finalize(IReportContext context, IScope scope, object result) {
if (scope.Get("store_render").ToBool()) {
scope[scope.Get("render_name", "render_result")] = result;
}
if (!scope.Get("no_render").ToBool()) {
context.Write(result.ToString());
}
}
/// <summary>
/// Constructor of service for managing reports.
/// </summary>
/// <param name="reportContext">Report context.</param>
/// <param name="mapper">Automapper.</param>
/// <param name="logger">Logging service.</param>
public ReportService(IReportContext reportContext,
IMapper mapper,
ILogger logger)
{
_reportContext = reportContext ?? throw new ArgumentNullException(nameof(reportContext));
_mapper = mapper ?? throw new ArgumentNullException(nameof(mapper));
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
}
public override async Task Execute(IReportContext context, ReportPhase phase, IScope scope = null) {
SetupMime(context);
if (BuildHtml) {
DoBuildHtml(context, scope);
} else {
DoStreamRender(context, scope);
}
}
/// <summary>
/// Seed application context.
/// </summary>
/// <param name="context">Application context.</param>
public static async Task SeedAsync(IReportContext context)
{
if (!context.Reports.Any())
{
await context.Reports.AddRangeAsync(GetPreconfiguredReportsModels());
await context.SaveChangesAsync(new CancellationToken());
}
}
protected virtual void Finalize(IReportContext context, IScope scope, object result)
{
if (scope.Get("store_render").ToBool())
{
scope[scope.Get("render_name", "render_result")] = result;
}
if (!scope.Get("no_render").ToBool())
{
context.Write(result.ToString());
}
}
private XElement RenderXml(IReportContext context, IScope scope, string templateUri, object item,
string templatename)
{
var ws = Render(context, scope, templateUri, item, templatename, true);
if (null == ws)
{
return(null);
}
return(ws.Get <XElement>(templatename));
}
private void SetupMime(IReportContext context)
{
if (string.IsNullOrWhiteSpace(MimeType))
{
MimeType = "text/html";
}
if ((MimeType.Contains("text") || MimeType.Contains("json")) && !MimeType.Contains("charset"))
{
MimeType += "; charset=utf-8";
}
context.SetHeader("Content-Type", MimeType);
}
public override async Task Execute(IReportContext context, ReportPhase phase, IScope scope = null)
{
SetupMime(context);
if (BuildHtml)
{
DoBuildHtml(context, scope);
}
else
{
DoStreamRender(context, scope);
}
}
public bool TryReport(IReportContext context)
{
if (context.RequestFactory.Aborted) // sanity.
{
return false;
}
var allowed = CanReport(context);
if (allowed)
{
EmitReport(context);
}
return allowed;
}
public bool TryReport(IReportContext context)
{
if (context.RequestFactory.Aborted) // sanity.
{
return(false);
}
var allowed = CanReport(context);
if (allowed)
{
EmitReport(context);
}
return(allowed);
}
public static void Hook( IReportContext context )
{
if( context == null )
{
throw new ArgumentNullException( "context" );
}
_context = context;
System.Windows.Forms.Application.ThreadException +=
new System.Threading.ThreadExceptionEventHandler( Application_ThreadException );
AppDomain.CurrentDomain.UnhandledException +=
new UnhandledExceptionEventHandler( CurrentDomain_UnhandledException );
}
public virtual bool IsMatch(IReportContext context)
{
if (context.Request.Flags.Contains("-" + Id))
{
return(false);
}
if (context.Request.Flags.Contains("explicit"))
{
if (!context.Request.Flags.Contains(Id))
{
return(false);
}
}
return(true);
}
public static bool IsSet(this IReportContext context, string flag)
{
if (context.Request.Flags.Contains(flag))
{
return(true);
}
if (null != context.Scope)
{
if (context.Scope.ContainsKey(flag))
{
return(context.Scope.Get(flag).ToBool());
}
}
return(false);
}
protected void LogSqlStatement(IReportContext reportContext, IQueryable <TReportObject> query, int logTag)
{
string text = query.Expression.ToString();
string sqlCommandText = reportContext.GetSqlCommandText(query);
this.TaskContext.WriteVerbose(Strings.InformationSqlStatement(sqlCommandText));
this.TaskContext.WriteVerbose(Strings.InformationQueryExpression(text));
ExTraceGlobals.ReportingWebServiceTracer.Information <string>(0L, "SQL Query: {0}", sqlCommandText);
ExTraceGlobals.ReportingWebServiceTracer.Information <string>(0L, "Expression: {0}", text);
if (this.StatementLogged != null)
{
this.StatementLogged("SQLStatement" + logTag.ToString(), Strings.InformationSqlStatement(sqlCommandText));
this.StatementLogged("QueryExpression" + logTag.ToString(), Strings.InformationQueryExpression(text));
}
}
protected override IQueryable <TReportObject> GetReportQuery(IReportContext reportContext)
{
IQueryable <TReportObject> queryable = base.GetReportQuery(reportContext);
if (!DataMart.Instance.IsTableFunctionQueryDisabled)
{
base.LogSqlStatement(reportContext, queryable, 2);
queryable = reportContext.GetScaledQuery <TReportObject>(queryable);
QueryDecorator <TReportObject> queryDecorator = this.queryDecorators.Single((QueryDecorator <TReportObject> decorator) => decorator is OrderByDecorator <TReportObject, DateTime>);
if (queryDecorator != null)
{
queryable = queryDecorator.GetQuery(queryable);
}
}
return(queryable);
}
/// <summary>
/// Gets the report builders that correspond to the given <paramref name="reportConfiguration" />.
/// </summary>
/// <param name="reportContext">The report context.</param>
/// <returns>
/// The report builders.
/// </returns>
public IEnumerable <IReportBuilder> GetReportBuilders(IReportContext reportContext)
{
Logger.DebugFormat(Resources.InitializingReportBuilders, string.Join(", ", reportContext.ReportConfiguration.ReportTypes));
var reportBuilders = this.pluginLoader.LoadInstancesOfType <IReportBuilder>()
.Where(r => reportContext.ReportConfiguration.ReportTypes.Contains(r.ReportType, StringComparer.OrdinalIgnoreCase))
.OrderBy(r => r.ReportType)
.ToArray();
var result = new List <IReportBuilder>();
foreach (var reportBuilderGroup in reportBuilders.GroupBy(r => r.ReportType))
{
if (reportBuilderGroup.Count() == 1)
{
result.Add(reportBuilderGroup.First());
}
else
{
var nonDefaultParsers = reportBuilderGroup
.Where(r => r.GetType().Assembly.GetName().Name != "ReportGenerator.Core")
.ToArray();
foreach (var reportBuilder in nonDefaultParsers)
{
result.Add(reportBuilder);
}
if (nonDefaultParsers.Length > 1)
{
Logger.WarnFormat(Resources.SeveralCustomReportBuildersWithSameReportType, reportBuilderGroup.Key);
}
if (nonDefaultParsers.Length < reportBuilderGroup.Count())
{
Logger.WarnFormat(Resources.DefaultReportBuilderReplaced, reportBuilderGroup.Key);
}
}
}
foreach (var reportBuilder in result)
{
reportBuilder.ReportContext = reportContext;
}
return(result);
}
private void DoBuildHtml(IReportContext context, IScope scope)
{
var htmlconfig = new HtmlConfig();
bool standalone = context.Request.Standalone;
if (standalone)
{
htmlconfig.DocHeader = RenderXml(context, scope, DocHeader, null, "DocHeader");
}
htmlconfig.Header = RenderXml(context, scope, Header, null, "Header");
htmlconfig.Content = RenderXml(context, scope, Content, null, "Content");
var items = context.Data.arr("items");
IList <ItemXml> xitems = new List <ItemXml>();
if (null != items)
{
var i = 0;
foreach (var item in items)
{
var itemScope = new Scope(scope);
itemScope["_item"] = item;
itemScope["_idx"] = i;
var xitem = new ItemXml();
xitem.Before = RenderXml(context, itemScope, BeforeItem, item, "BeforeItem");
xitem.Item = RenderXml(context, itemScope, Item, item, "Item");
xitem.After = RenderXml(context, itemScope, AfterItem, item, "AfterItem");
if (null != (xitem.Before ?? xitem.After ?? xitem.Before))
{
xitems.Add(xitem);
}
i++;
}
}
htmlconfig.Items = xitems;
htmlconfig.Footer = RenderXml(context, scope, Footer, null, "Footer");
XElement docfooter = null;
if (standalone)
{
htmlconfig.DocFooter = RenderXml(context, scope, DocFooter, null, "DocFooter");
}
var xmlhtml = CompileHtml(context, scope, htmlconfig);
context.Write(xmlhtml.ToString());
}
public void Execute()
{
try
{
ReportingTaskFaultInjection.FaultInjectionTracer.TraceTest(4140182845U);
using (IDbConnection dbConnection = this.reportContextFactory.CreateConnection(false))
{
using (IDbConnection dbConnection2 = this.reportContextFactory.CreateConnection(true))
{
IDbConnection connection = this.OpenConnections(dbConnection, dbConnection2);
using (IReportContext reportContext = this.reportContextFactory.CreateReportContext(connection))
{
IQueryable <TReportObject> reportQuery = this.GetReportQuery(reportContext);
this.LogSqlStatement(reportContext, reportQuery, 1);
foreach (TReportObject reportObject in reportQuery)
{
this.RaiseReporReceivedtEvent(reportObject);
}
}
}
}
}
catch (SqlException sqlException)
{
this.HandleSqlError(sqlException);
}
catch (SqlTypeException sqlTypeException)
{
this.HandleSqlError(sqlTypeException);
}
catch (ArgumentException argumentException)
{
this.HandleLinqError(argumentException);
}
catch (InvalidOperationException invalidOperationException)
{
this.HandleTimeoutError(invalidOperationException);
throw;
}
}
private void EmitReport(IReportContext context)
{
log.Debug(Debugging.Report_Emitting.FormatWith(context.RequestFactory.Id));
IList <ProfileItem> results = context.Snapshot();
IList <RequestItem> pending = context.Pending();
TimeSpan duration = context.Duration;
int successful = results.Count(r => r.Response.StatusCode == HttpStatusCode.OK);
int timedOut = results.Count(r => r.Response.ResponseStatus == ResponseStatus.TimedOut);
double responseTime = 0;
if (results.Any() || pending.Any())
{
responseTime = (pending.Sum(item => item.Elapsed.TotalSeconds) + results.Sum(item => item.Elapsed.TotalSeconds))
/ (results.Count() + pending.Count());
}
var dto = new DroneSnapshotDto
{
Name = Info.Report_Name.FormatWith(context.RequestFactory.Id, context.InternalId),
ExecutionId = context.RequestFactory.ExecutionId,
DroneId = context.DroneId,
Started = context.Started,
Duration = duration,
CurrentWorkload = new DroneWorkloadDto
{
Average = results.Count / duration.TotalSeconds,
AverageResponseTime = responseTime,
Completed = results.Count,
Successful = successful,
Failed = results.Count - successful,
TimedOut = timedOut
},
VirtualUsers = context.Users()
};
Task.Factory.StartNew(() => report(dto)); // report async.
}
private async Task ExecutePhase(IReportContext context, ReportPhase phase,IScope scope) {
Logg.Debug(new {op="start phase",phase});
var agents = context.Agents.Where(_ => _.Phase.HasFlag(phase)).OrderBy(_ => _.Idx).GroupBy(_ => _.Idx).ToArray();
foreach (var grp in agents) {
if (grp.Count() == 1) {
await grp.First().Execute(context, phase, scope);
}
else if (grp.All(_ => _.Parallel)) {
var waitgroup = new List<Task>();
foreach (var agent in grp) {
waitgroup.Add(agent.Execute(context, phase, scope));
}
Task.WaitAll(waitgroup.ToArray());
}
else {
foreach (var agent in grp) {
await agent.Execute(context, phase, scope);
}
}
}
Logg.Debug(new { op = "end phase", phase });
}
public override IScope Render(IReportContext context, IScope scope, object item) {
scope = scope ?? context.Scope;
Template = Template ?? XmlExtensions.Load(FileName,BxlParserOptions.ExtractSingle);
Xi = Xi ?? new XmlInterpolation { UseExtensions = true, XmlIncludeProvider = new XmlIncludeProvider {Container = _container} };
IScope ws = null;
if (null == context) {
ws = scope;
}
else {
ws = new Scope(context.Data);
ws["data"] = context.Data;
ws["context"] = context;
ws["scope"] = scope;
ws["item"] = item;
ws["reportcode"] = context.Report.Id;
ws["reportname"] = context.Report.Name;
}
var result = Xi.Interpolate(Template, ws);
RemoveDebugInfo(scope, result);
Finalize(context, scope, result);
return scope;
}
private void EmitReport(IReportContext context)
{
log.Debug(Debugging.Report_Emitting.FormatWith(context.RequestFactory.Id));
IList<ProfileItem> results = context.Snapshot();
IList<RequestItem> pending = context.Pending();
TimeSpan duration = context.Duration;
int successful = results.Count(r => r.Response.StatusCode == HttpStatusCode.OK);
int timedOut = results.Count(r => r.Response.ResponseStatus == ResponseStatus.TimedOut);
double responseTime = 0;
if (results.Any() || pending.Any())
{
responseTime = (pending.Sum(item => item.Elapsed.TotalSeconds) + results.Sum(item => item.Elapsed.TotalSeconds))
/(results.Count() + pending.Count());
}
var dto = new DroneSnapshotDto
{
Name = Info.Report_Name.FormatWith(context.RequestFactory.Id, context.InternalId),
ExecutionId = context.RequestFactory.ExecutionId,
DroneId = context.DroneId,
Started = context.Started,
Duration = duration,
CurrentWorkload = new DroneWorkloadDto
{
Average = results.Count / duration.TotalSeconds,
AverageResponseTime = responseTime,
Completed = results.Count,
Successful = successful,
Failed = results.Count - successful,
TimedOut = timedOut
},
VirtualUsers = context.Users()
};
Task.Factory.StartNew(() => report(dto)); // report async.
}
public abstract IScope Render(IReportContext context, IScope scope, object item);
private XElement CompileHtml(IReportContext context, IScope scope, HtmlConfig htmlconfig)
{
bool standalone = context.Request.Standalone;
XElement root = null;
XElement content = XElement.Parse("<section><header></header><main></main><footer></footer></section>");
if (standalone)
{
root = XElement.Parse("<html class='" + HtmlClass + $"'><head><meta charset='UTF-8' /></head><body class='{BodyClass}'></body></html>");
root.Element("body").Add(content);
if (null != htmlconfig.DocHeader)
{
root.Element("head").Add(htmlconfig.DocHeader.Elements());
}
}
else
{
root = content;
}
if (null != htmlconfig.Header)
{
content.Element("header").ReplaceWith(htmlconfig.Header);
}
var main = content.Element("main");
if (null != htmlconfig.Content)
{
main.ReplaceWith(htmlconfig.Content);
main = content.Element("main");
}
if (null != htmlconfig.Items && 0 != htmlconfig.Items.Count)
{
foreach (var item in htmlconfig.Items)
{
if (null == item.Before && null == item.After)
{
var e = XElement.Parse("<div class='report_item'></div>");
if (null != item.Before)
{
e.Add(item.Before);
}
if (null != item.Item)
{
e.Add(item.Item);
}
if (null != item.After)
{
e.Add(item.After);
}
main.Add(e);
}
else if (null != item.Item)
{
main.Add(item.Item);
}
}
}
if (null != htmlconfig.Footer)
{
content.Element("footer").ReplaceWith(htmlconfig.Footer);
}
if (standalone)
{
if (null != htmlconfig.DocFooter)
{
root.Element("body").Add(htmlconfig.DocFooter);
}
}
return(root);
}
public override async Task Execute(IReportContext context, ReportPhase phase, IScope scope = null) {
context.Data["x"] = 1;
}
public ReportRepository()
{
Reportctx = new ReportSQLQuery();
}
bool IReport.TryReport(IReportContext context)
{
throw new NotSupportedException();
}
private IScope Render(IReportContext context, IScope scope, string templateUri, object item, string templateName, bool cache = false) {
if (string.IsNullOrWhiteSpace(templateUri)) {
return null;
}
if (context.IsSet("-render_" + templateName.ToLowerInvariant())) {
return null;
}
if (!templateCache.ContainsKey(templateUri)) {
templateCache[templateUri] = Renders.GetRender(templateUri, scope);
}
var template = templateCache[templateUri];
if (null == template) {
throw new Exception("cannot find template " + templateUri);
}
var ts = scope;
if (cache) {
ts = new Scope(ts);
ts["store_render"] = true;
ts["no_render"] = true;
ts["render_name"] = templateName;
}
var result = template.Render(context, ts, item);
return result;
}
public CleanupHtmlRenderTask(IReportContext reportContext)
{
_logger = reportContext.LoggerFactory.CreateLogger <CleanupHtmlRenderTask>();
_reportContext = reportContext;
}
public ReportManagmentService(IReportContext context)
{
_context = context ?? throw new ArgumentNullException(nameof(context));
}
/// <summary>
/// Context
/// </summary>
/// <param name="context"></param>
/// <param name="reportContext"></param>
public WidgetService(IDashboardDbContext context, IReportContext reportContext)
{
_context = context;
_reportContext = reportContext;
}
/// <summary>
/// Initializes a new instance of the class.
/// </summary>
public ReportBuilder(IReportContext reportContext)
{
ReportContext = reportContext ?? throw new ArgumentNullException(nameof(reportContext));
}
public abstract bool CanReport(IReportContext context);
private void DoStreamRender(IReportContext context, IScope scope) {
if (context.Request.Standalone) {
Render(context, scope, DocHeader, null, "DocHeader");
}
Render(context, scope, Header, null, "Header");
Render(context, scope, Content, null, "Content");
var items = context.Data.arr("items");
if (null != items) {
var i = 0;
foreach (var item in items) {
var itemScope = new Scope(scope);
itemScope["_item"] = item;
itemScope["_idx"] = i;
Render(context, itemScope, BeforeItem, item, "BeforeItem");
Render(context, itemScope, Item, item, "Item");
Render(context, itemScope, AfterItem, item, "AfterItem");
i++;
}
}
Render(context, scope, Header, null, "Footer");
if (context.Request.Standalone) {
Render(context, scope, DocFooter, null, "DocFooter");
}
}
bool IReportDefinitionCustomizationExtension.ProcessReportDefinition(byte[] reportDefinition, IReportContext reportContext, IUserContext userContext, out byte[] reportDefinitionProcessed, out IEnumerable <RdceCustomizableElementId> customizedElementIds)
{
//load report from byte[]
XmlDocument d = new XmlDocument();
MemoryStream ms = null;
using (ms = new MemoryStream(reportDefinition))
{
d.Load(ms);
ms.Position = 0;
}
XElement report = XElement.Load(new XmlNodeReader(d));
//run all transformations
if (_transformations != null)
{
foreach (ITransformation t in _transformations)
{
report = t.Transform(report, reportContext, userContext);
}
}
//convert report to byte[] so it can be returned to SSRS
System.Text.Encoding enc = new System.Text.UTF8Encoding();
reportDefinitionProcessed = enc.GetBytes(report.ToString());
//we have to inform SSRS about what we changed. In this sample we only change the body part of the report.
//Other values are: DataSets, Page, PageHeader, PageFooter
List <RdceCustomizableElementId> ids = new List <RdceCustomizableElementId>();
customizedElementIds = new List <RdceCustomizableElementId>();
(customizedElementIds as List <RdceCustomizableElementId>).Add(RdceCustomizableElementId.Body);
return(true);
}
public PostLogic()
{
_context = new PostOracleContext();
_reportContext = new ReportOracleContext();
}
public override async Task Execute(IReportContext context, ReportPhase phase, IScope scope = null)
{
context.Data["x"] = 1;
}
public override bool CanReport(IReportContext context)
{
return true;
}
private XElement CompileHtml(IReportContext context, IScope scope, HtmlConfig htmlconfig) {
bool standalone = context.Request.Standalone;
XElement root = null;
XElement content = XElement.Parse("<section><header></header><main></main><footer></footer></section>");
if (standalone) {
root = XElement.Parse("<html class='" + HtmlClass + $"'><head><meta charset='UTF-8' /></head><body class='{BodyClass}'></body></html>");
root.Element("body").Add(content);
if (null != htmlconfig.DocHeader) {
root.Element("head").Add(htmlconfig.DocHeader.Elements());
}
} else {
root = content;
}
if (null != htmlconfig.Header) {
content.Element("header").ReplaceWith(htmlconfig.Header);
}
var main = content.Element("main");
if (null != htmlconfig.Content) {
main.ReplaceWith(htmlconfig.Content);
main = content.Element("main");
}
if (null != htmlconfig.Items && 0 != htmlconfig.Items.Count) {
foreach (var item in htmlconfig.Items) {
if (null == item.Before && null == item.After) {
var e = XElement.Parse("<div class='report_item'></div>");
if (null != item.Before) {
e.Add(item.Before);
}
if (null != item.Item) {
e.Add(item.Item);
}
if (null != item.After) {
e.Add(item.After);
}
main.Add(e);
} else if (null != item.Item) {
main.Add(item.Item);
}
}
}
if (null != htmlconfig.Footer) {
content.Element("footer").ReplaceWith(htmlconfig.Footer);
}
if (standalone) {
if (null != htmlconfig.DocFooter) {
root.Element("body").Add(htmlconfig.DocFooter);
}
}
return root;
}
private void SetupMime(IReportContext context) {
if (string.IsNullOrWhiteSpace(MimeType)) {
MimeType = "text/html";
}
if ((MimeType.Contains("text") || MimeType.Contains("json")) && !MimeType.Contains("charset")) {
MimeType += "; charset=utf-8";
}
context.SetHeader("Content-Type", MimeType);
}
private XElement RenderXml(IReportContext context, IScope scope, string templateUri, object item,
string templatename) {
var ws = Render(context, scope, templateUri, item, templatename, true);
if (null == ws) return null;
return ws.Get<XElement>(templatename);
}
public UnitOfWork(IReportContext context)
{
this.context = context;
}
public PostLogic(IPostContext context)
{
_context = context;
_reportContext = new ReportOracleContext();
}
