public string outputBase(Asset asset, OutputContext context, string name, string index = "")
{
StringBuilder sbContent = new StringBuilder();
sbContent.Append(componentMarkup);
String markup = ComponentLibraryHelper.updateMarkupForPreviewPublish(context, sbContent.ToString());
return markup;
}
protected override void RegisterProcess(ContainerBuilder builder, Process original) {
builder.Register<IProcessController>(ctx => {
var pipelines = new List<IPipeline>();
var deleteHandlers = new List<IEntityDeleteHandler>();
// entity-level pipelines
foreach (var entity in original.Entities) {
pipelines.Add(ctx.ResolveNamed<IPipeline>(entity.Key));
if (entity.Delete) {
deleteHandlers.Add(ctx.ResolveNamed<IEntityDeleteHandler>(entity.Key));
}
}
// process-level pipeline
pipelines.Add(ctx.ResolveNamed<IPipeline>(original.Key));
var outputProvider = original.Connections.First(c => c.Name == "output").Provider;
var context = new PipelineContext(ctx.Resolve<IPipelineLogger>(), original);
var controller = new ProcessController(pipelines, deleteHandlers);
if (original.Mode == "init") {
switch (outputProvider) {
case "sqlserver":
var output = new OutputContext(context, new Incrementer(context));
controller.PreActions.Add(new SqlInitializer(output));
controller.PostActions.Add(new SqlStarViewCreator(output));
break;
}
}
// templates
foreach (var template in original.Templates.Where(t => t.Enabled)) {
controller.PreActions.Add(new RenderTemplateAction(template, ctx.ResolveNamed<ITemplateEngine>(template.Key)));
foreach (var action in template.Actions.Where(a => a.GetModes().Any(m => m == original.Mode))) {
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 original.Actions.Where(a => a.GetModes().Any(m => m == original.Mode))) {
if (action.Before) {
controller.PreActions.Add(ctx.ResolveNamed<IAction>(action.Key));
}
if (action.After) {
controller.PostActions.Add(ctx.ResolveNamed<IAction>(action.Key));
}
}
return controller;
}).Named<IProcessController>(original.Key);
}
void Start()
{
OutputContext context = new OutputContext(new CSVOutput(' '));
Debug.Log("This is the CSV output:\n" + context.GetOutput(input));
//Easily change the context!
context = new OutputContext(new EncryptedOutput());
Debug.Log("This is the encrypted output:\n" + context.GetOutput(input));
}
public static void Check(string source, string expected)
{
var input = new InputContext();
if (input.Compile(new List<Input> { new Input("<test>", source) })) {
var output = new OutputContext(input);
Assert.AreEqual(expected, output.Code);
} else {
Assert.AreEqual(expected, input.GenerateLog());
}
}
public string outputBase(Asset asset, OutputContext context, string name, string index = "")
{
StringBuilder sbContent = new StringBuilder();
sbContent.Append(componentMarkup);
Dictionary<List<String>, Func<Asset, OutputContext, String, String, String>> module_instances_fields = new Dictionary<List<String>, Func<Asset, OutputContext, String, String, String>>();
List<String> module_instances_fieldParams = new List<String>();
module_instances_fieldParams.Add(@"{ih_module_instance}");
module_instances_fieldParams.Add("_module_instances");
module_instances_fields.Add(module_instances_fieldParams, this.ih_module_instance.output);
sbContent.Replace(@"<cp-list name=""module_instances"">{ih_module_instance}</cp-list>", panel_output(asset, context, name + "_panel", @"{ih_module_instance}", "module_instances", module_instances_fields, index));
String markup = ComponentLibraryHelper.updateMarkupForPreviewPublish(context, sbContent.ToString());
return markup;
}
public override string output(Asset asset, OutputContext context, string name, string index = "")
{
var output = new StringBuilder();
// Establish content field names
EnsureContentFieldNames(name, index);
// Establish input form field and element attribute names
var editableAttributes = Util.Editable(_moduleInstanceIdField);
// Add supporting css/js and an editor wrapper for edit mode only
if (!context.IsPublishing)
{
if (!IsWidgetMode)
{
output.Append("<link rel=\"stylesheet\" href=\"https://maxcdn.bootstrapcdn.com/bootstrap/3.3.6/css/bootstrap.min.css\">");
output.Append("<script src=\"https://ajax.googleapis.com/ajax/libs/jquery/1.12.0/jquery.min.js\"></script>");
output.Append("<script src=\"https://maxcdn.bootstrapcdn.com/bootstrap/3.3.6/js/bootstrap.min.js\"></script>");
}
output.Append("<span " + editableAttributes + "><div style=\"visibility:hidden;height:0px;width:0px;\">editor_placeholder</div>");
}
if (asset.GetContentFields().ContainsKey(_moduleInstanceIdField) && !string.IsNullOrEmpty(asset[_moduleInstanceIdField]))
{
EnsureConfigSettings(asset);
_authToken = Ih_AuthenticationHelper.GetAuthToken(true, context.UserInfo, _configSettings);
var moduleInstanceId = asset[_moduleInstanceIdField];
var prerenderMarkup = Boolean.Parse(GetValueOrDefault(asset[_prerenderMarkupFieldName], true.ToString())) || (IsWidgetMode && !context.IsPublishing);
IncrementModuleInstanceIndex(context, !prerenderMarkup);
// Render module instance markup
if (context.IsPublishing || IsWidgetMode)
RenderModuleOutputForWeb(asset, context, output, moduleInstanceId, prerenderMarkup);
else
RenderModuleOutputForCms(context, output, moduleInstanceId, name, index);
}
else
{
if (!context.IsPublishing)
output.Append("<div style=\"border:1px solid lightgray;color:gray;padding:5px;text-align:center\">No Module Instance Selected</div>");
}
// Finalize editor wrapper
if (!context.IsPublishing)
output.Append("</span>");
return output.ToString();
}
public SqlEntityBulkInserter(OutputContext output) {
_output = output;
_bulkCopyOptions = SqlBulkCopyOptions.Default;
TurnOptionOn(SqlBulkCopyOptions.TableLock);
TurnOptionOn(SqlBulkCopyOptions.UseInternalTransaction);
TurnOptionOff(SqlBulkCopyOptions.CheckConstraints);
TurnOptionOff(SqlBulkCopyOptions.FireTriggers);
TurnOptionOn(SqlBulkCopyOptions.KeepNulls);
_keys = output.Entity.GetPrimaryKey();
_outputKeysReader = new SqlEntityMatchingKeysReader(output, _keys);
_sqlUpdater = new SqlEntityUpdater(output);
}
public override void LoadEntity(ContainerBuilder builder, Process process, Entity entity) {
//master updater
builder.Register<IUpdate>((ctx) => {
var context = new PipelineContext(ctx.Resolve<IPipelineLogger>(), process, entity);
var incrementer = new Incrementer(context);
var output = new OutputContext(context, incrementer);
switch (output.Connection.Provider) {
case "sqlserver":
context.Debug("Registering {0} master updater", output.Connection.Provider);
return new SqlMasterUpdater(output);
default:
context.Warn("Registering null updater");
return new NullMasterUpdater();
}
}).Named<IUpdate>(entity.Key);
}
public override void LoadEntity(ContainerBuilder builder, Process process, Entity entity) {
builder.Register<IEntityController>(ctx => {
var context = new PipelineContext(ctx.Resolve<IPipelineLogger>(), process, entity);
var output = new OutputContext(context, new Incrementer(context));
switch (output.Connection.Provider) {
case "sqlserver":
context.Debug("Registering sql server controller");
var initializer = process.Mode == "init" ? (IAction)new SqlEntityInitializer(output) : new NullInitializer();
return new SqlEntityController(output, initializer);
default:
context.Debug("Registering null controller");
return new NullEntityController();
}
}).Named<IEntityController>(entity.Key);
}
public override string output(Asset asset, OutputContext context, string name, string index = "")
{
var output = new StringBuilder();
// Establish content field names
EnsureContentFieldNames(name, index);
// Establish user variable names
EnsureUserVariableNames(context);
// Establish input form field and element attribute names
var editableAttributes = Util.Editable(_moduleInstanceIdField);
// Add wrapper for edit mode only
if (!context.IsPublishing)
output.Append("<span " + editableAttributes + "><div style=\"visibility:hidden;height:0px;width:0px;\">editor_placeholder</div>");
if (asset.GetContentFields().ContainsKey(_moduleInstanceIdField) && !string.IsNullOrEmpty(asset[_moduleInstanceIdField]))
{
EnsureConfigSettings(asset);
_authToken = Ih_AuthenticationHelper.GetAuthToken(false, context.UserInfo, _configSettings);
var moduleInstanceId = asset[_moduleInstanceIdField];
var prerenderMarkup = Boolean.Parse(GetValueOrDefault(asset[_prerenderMarkupFieldName], true.ToString()));
IncrementModuleInstanceIndex(context, !prerenderMarkup);
// Render module instance markup
if (context.IsPublishing)
RenderModuleOutputForWeb(asset, context, output, moduleInstanceId, prerenderMarkup);
else
RenderModuleOutputForCms(asset, context, output, moduleInstanceId, name, index);
}
else
{
if (!context.IsPublishing)
output.Append("<div style=\"border:1px solid lightgray;color:gray;padding:5px;text-align:center\">No Module Instance Selected</div>");
}
// Finalize editor wrapper
if (!context.IsPublishing)
output.Append("</span>");
return output.ToString();
}
public override string output(Asset asset, OutputContext context, string name, string index = "")
{
var output = new StringBuilder();
// Ensure admin UI is never published
if (context.IsPublishing)
return string.Empty;
// Get all site roots that the current user is allowed to access
_allowedSiteRoots = FindAllowedSiteRoots(context);
// Get selected site root asset Id
if (context.PublishingArgs.HasArg(_siteRootAssetIdParam))
_selectedSiteRootAssetId = int.Parse(context.PublishingArgs[_siteRootAssetIdParam]);
// Load content app intance configuration
if (!EnsureConfigSettings(asset))
{
return CreateErrorMessage("You are not authorized to administrate Content Apps.");
}
// Acquire an authentication token
var token = Ih_AuthenticationHelper.GetAuthToken(true, context.UserInfo, _configSettings);
// Render iframe containing content apps admin
var startPageFieldNameComplete = name + _startPageFieldName + index;
if (asset.GetContentFields().ContainsKey(startPageFieldNameComplete))
{
var adminUrl = asset[startPageFieldNameComplete];
if (!string.IsNullOrEmpty(adminUrl))
output.AppendLine(GetAdminIFrameMarkup(asset, context, adminUrl, token));
}
else
{
return CreateErrorMessage("No Start Page URL was configured");
}
return output.ToString();
}
public DelimitedFileStreamWriter(OutputContext context, Stream stream)
{
_context = context;
_stream = stream;
}
// Returns the HTML markup for rendering an iframe for the specified amdin URL
private string GetAdminIFrameMarkup(Asset asset, OutputContext context, string adminUrl, string token)
{
var output = new StringBuilder();
output.Append("<html><body>");
output.Append("<div style='padding:5px;width:99%;height:22px;background-color:silver;color:black;'>");
// Site selection markup/script
if (_allowedSiteRoots.Count > 1)
{
output.Append(" Site ");
output.Append("<script type='text/javascript'>function siteSelectionChanged(siteSelect) { document.getElementById('admin_iframe').style.display = 'none'; document.getElementById('loadingPanel').style.display = ''; document.location.href = siteSelect.value; }</script>");
output.Append("<select onchange='siteSelectionChanged(this)'>");
foreach (var site in _allowedSiteRoots)
{
output.Append(CreateSiteSelectionOption(asset, site.SiteRootAssetId.ToString(), site.ClientName));
}
output.Append("</select><span id='loadingPanel' style='display:none'> Loading...</span>");
}
output.Append("</div>");
// Iframe markup/script
var adminAbsoluteUrl = string.IsNullOrEmpty(token) ? string.Empty : _servicesEndPoint + adminUrl + "?authtoken=" + token + "&noredirect=true";
if (string.IsNullOrEmpty(adminAbsoluteUrl))
output.Append(CreateErrorMessage("Unable to load content apps administration. Please try again."));
else
{
output.Append("<iframe id=\"admin_iframe\" src=\"" + adminAbsoluteUrl + "\" style=\"width:100%;height:0px\" style=\"overflow-x:hidden;\" scrolling=\"yes\" frameBorder=\"0\"></iframe>");
// Frame resize script
output.Append("<script type='text/javascript'>document.getElementById('admin_iframe').style.height = ((window.innerHeight - 55) + 'px');</script>");
}
output.Append("</body></html>");
return output.ToString();
}
public static FileHelperAsyncEngine Create(OutputContext context)
{
var delimiter = string.IsNullOrEmpty(context.Connection.Delimiter) ? "," : context.Connection.Delimiter;
var builder = new DelimitedClassBuilder(Utility.Identifier(context.Entity.OutputTableName(context.Process.Name)))
{
IgnoreEmptyLines = true,
Delimiter = delimiter,
IgnoreFirstLines = 0
};
var fields = context.Entity.GetAllOutputFields().Where(f => !f.System).ToArray();
if (context.Connection.TextQualifier == string.Empty)
{
foreach (var field in fields)
{
var fieldBuilder = builder.AddField(field.FieldName(), typeof(string));
fieldBuilder.FieldQuoted = false;
fieldBuilder.QuoteMultiline = MultilineMode.NotAllow;
fieldBuilder.FieldOptional = field.Optional;
}
}
else
{
foreach (var field in fields)
{
var fieldBuilder = builder.AddField(field.FieldName(), typeof(string));
fieldBuilder.FieldQuoted = true;
fieldBuilder.QuoteChar = context.Connection.TextQualifier[0];
fieldBuilder.QuoteMultiline = MultilineMode.AllowForBoth;
fieldBuilder.QuoteMode = QuoteMode.OptionalForBoth;
fieldBuilder.FieldOptional = field.Optional;
}
}
Enum.TryParse(context.Connection.ErrorMode, true, out global::FileHelpers.ErrorMode errorMode);
FileHelperAsyncEngine engine;
if (context.Connection.Header == Constants.DefaultSetting)
{
var headerText = string.Join(delimiter, fields.Select(f => f.Label.Replace(delimiter, " ")));
engine = new FileHelperAsyncEngine(builder.CreateRecordClass())
{
ErrorMode = errorMode,
HeaderText = headerText,
FooterText = context.Connection.Footer
};
}
else
{
engine = new FileHelperAsyncEngine(builder.CreateRecordClass())
{
ErrorMode = errorMode
};
if (context.Connection.Header != string.Empty)
{
engine.HeaderText = context.Connection.Header;
}
if (context.Connection.Footer != string.Empty)
{
engine.FooterText = context.Connection.Footer;
}
}
return(engine);
}
public JsonNetSerializer(OutputContext context)
{
_context = context;
}
public SqlEntityUpdater(OutputContext output)
{
_output = output;
}
public virtual IDom CreateFrom(SyntaxTrivia trivia, IDom parent, OutputContext context)
{
throw new NotImplementedException();
}
public AdoFlattenInsertBySelectAction(OutputContext output, IConnectionFactory cf, AdoSqlModel model)
{
_output = output;
_cf = cf;
_model = model;
}
/*comment out "outputBase(asset, context, name, index);" & modify this function if you want to overwrite the output functionality of the component.*/
public override string output(Asset asset, OutputContext context, string name, string index = "")
{
return outputBase(asset, context, name, index);
}
public override void CodeGen(OutputContext output)
{
Body.Print(output);
output.Semicolon();
}
public override void CodeGen(OutputContext output)
{
DoPrint(output, "let");
}
public SqlInitializer(OutputContext context)
{
_context = context;
_connectionString = _context.Process.Connections.First(c => c.Name == "output").GetConnectionString();
}
public override string GetDocFile(OutputContext context)
{
return(context.ToFileName(Info.FullName));
}
protected override IEnumerable <(string, Action <DocumentFormatter>)> GetInfoBoxWriters(OutputContext context)
{
yield return("Namespace", output =>
{
Namespace.WriteLink(output, context);
});
yield return("Assembly", output =>
{
Namespace.Assembly.WriteLink(output, context);
output.Text(" (");
output.Text(string.Join(", ", Namespace.Assembly.Modules));
output.Text(") version ", Namespace.Assembly.Version);
});
if (HasInterface)
{
var interfaces = Info.GetInterfaces();
yield return("Implements", output =>
{
for (var i = 0; i < interfaces.Length; i++)
{
if (i != 0)
{
output.Text(", ");
}
output.LinkCRef(interfaces[i].GetCRef(), interfaces[i].GetDisplayName());
}
});
}
if (IsDerived)
{
yield return("Inheritance", output =>
{
foreach (var ancestor in Info.GetAncestors())
{
output.LinkCRef(ancestor.GetCRef(), ancestor.GetDisplayName());
output.Text("\u2002", ("\u2192", TextStyles.Teletype), "\u2002");
}
output.Text(Name);
});
}
}
public override void CodeGen(OutputContext output)
{
throw new InvalidOperationException();
}
public override void CodeGen(OutputContext output)
{
output.Print("undefined");
}
public static void RenderPreview(Asset asset, OutputContext context)
{
StringBuilder sbOutput = new StringBuilder();
sbOutput.AppendLine(@"
<html>
<head>
<title></title>
<style>
table.report{
width:100%;
background-color: white;
border-collapse: collapse;
border: 1px solid black;
}
table.report
table.report tr.header th{
background-color:#0066CC;
text-align:center;
color:white;
}
.datagrid table {
border-collapse: collapse;
text-align: left;
width: 100%;
}
.datagrid {
font: normal 12px/150% Arial, Helvetica, sans-serif;
background: #fff;
overflow: hidden;
border: 1px solid #A65B1A;
-webkit-border-radius: 3px;
-moz-border-radius: 3px;
border-radius: 3px;
}
.datagrid table td, .datagrid table th {
padding: 3px 0px;
}
.datagrid table thead th {
background: -webkit-gradient( linear, left top, left bottom, color-stop(0.05, #A65B1A), color-stop(1, #7F4614) );
background: -moz-linear-gradient( center top, #A65B1A 5%, #7F4614 100% );
filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#A65B1A', endColorstr='#7F4614');
background-color: #A65B1A;
color: #FFFFFF;
font-size: 15px;
font-weight: bold;
border-left: 1px solid #BF691E;
text-align: center;
}
.datagrid table thead th:first-child {
border: none;
}
.datagrid table tbody td {
color: #7F4614;
border-left: 1px solid #D9CFB8;
font-size: 12px;
font-weight: normal;
}
.datagrid table tbody .alt td {
background: #F0E5CC;
color: #7F4614;
}
.datagrid table tbody td:first-child {
border-left: none;
width: 180px;
padding: 10px 0 10px 10px;
}
.datagrid table tbody td:nth-child(2) {
padding: 10px 0 10px 20px;
}
.datagrid table tbody tr:last-child td {
border-bottom: none;
}
</style>
</head>
<body>
<div class=""datagrid"">
<table>
<thead>
<tr>
<th colspan=""2"">
Site Builder Summary
</th>
</tr>
</thead>
<tbody>
<tr>
<td>
Site Name
</td>
<td>"
);
switch (asset["site_type_option"])
{
case "single":
sbOutput.AppendLine(asset["single_site_name"]);
break;
case "collection":
sbOutput.AppendLine(asset["collection_name"]);
sbOutput.AppendLine("<ul>");
foreach (PanelEntry peSite in asset.GetPanels("collection_panel"))
{
sbOutput.AppendLine("<li>" + peSite["collection_site_name"] + "</li>");
}
sbOutput.AppendLine("</ul>");
break;
case "collection_tmf":
sbOutput.AppendLine(asset["collection_tmf_name"]);
sbOutput.AppendLine("<ul>");
foreach (PanelEntry peSite in asset.GetPanels("tmf_panel"))
{
sbOutput.AppendLine("<li>" + peSite["locale_name"] + "</li>");
}
sbOutput.AppendLine("</ul>");
break;
}
sbOutput.AppendLine(@"
</td>
</tr>
<tr class=""alt"">
<td>
Site Location in CMS
</td>
<td>
");
switch (asset["site_type_option"])
{
case "single":
sbOutput.AppendLine(string.Format("/{0}", asset["single_site_name"]));
break;
case "collection":
sbOutput.AppendLine(string.Format("/{0}", asset["collection_name"]));
break;
case "collection_tmf":
sbOutput.AppendLine(string.Format("/{0}", asset["collection_tmf_name"]));
break;
}
sbOutput.AppendLine(@"
</td>
</tr>
<tr>
<td>
Technology Stack
</td>
<td>
");
sbOutput.AppendLine(asset["language_type"].ToUpper());
sbOutput.AppendLine(@"
</td>
</tr>
<tr class=""alt"">
<td>
Folder Tree
</td>
<td>
");
switch (asset["site_type_option"])
{
case "single":
sbOutput.AppendLine(string.Format("/{0}/", asset["single_site_name"]));
break;
case "collection":
sbOutput.AppendLine(string.Format("/{0}<br>", asset["collection_name"]));
foreach (PanelEntry peSite in asset.GetPanels("collection_panel"))
{
sbOutput.AppendFormat("<span style=\"padding-left:2em\">/{0}</span><br>", peSite["collection_site_name"]);
}
break;
case "collection_tmf":
sbOutput.AppendLine(string.Format("/{0}<br>", asset["collection_tmf_name"]));
sbOutput.AppendLine("<span style=\"padding-left:2em\">/_TMF</span><br>");
foreach (PanelEntry peSite in asset.GetPanels("tmf_panel"))
{
sbOutput.AppendFormat("<span style=\"padding-left:2em\">/{0}</span><br>", peSite["locale_name"]);
}
break;
}
sbOutput.AppendLine(@"
</td>
</tr>
<tr>
<td>
Dual Output Selected
</td>
<td>
");
if (asset["include_mobile"].Equals("no"))
{
sbOutput.AppendLine("NO");
}
else
{
sbOutput.AppendLine("YES");
}
sbOutput.AppendLine(@"
</td>
</tr>
<tr class=""alt"">
<td>
Template Location
</td>
<td>
");
switch (asset["site_type_option"])
{
case "single":
sbOutput.AppendFormat("/System/Templates/{0}", asset["single_site_name"]);
break;
case "collection":
foreach (PanelEntry peSite in asset.GetPanels("collection_panel"))
{
sbOutput.AppendFormat("/System/Templates/{0}/{1}<br>", asset["collection_name"], peSite["collection_site_name"]);
}
break;
case "collection_tmf":
sbOutput.AppendFormat("/System/Templates/{0}<br>", asset["collection_tmf_name"]);
break;
}
sbOutput.AppendLine(@"
</td>
</tr>
<tr>
<td>
Model Location
</td>
<td>
");
string szModelLabel = string.Empty;
switch (asset["site_type_option"])
{
case "single":
szModelLabel = asset["single_site_name"];
break;
case "collection":
szModelLabel = asset["collection_name"];
break;
case "collection_tmf":
szModelLabel = asset["collection_tmf_name"];
break;
}
sbOutput.AppendFormat("/System/Models/{0}", szModelLabel);
sbOutput.AppendLine(@"
</td>
</tr>
<tr class=""alt"">
<td>
Library Folder Location
</td>
<td>
");
sbOutput.AppendLine("/System/Library");
sbOutput.AppendLine(@"
</td>
</tr>
</tbody>
</table>
</div>
</body>
</html>
");
Out.WriteLine(sbOutput.ToString());
}
public ElasticEntityInitializer(OutputContext context, IElasticLowLevelClient client)
{
_context = context;
_client = client;
}
public static bool RunLocalServer()
{
if (!HttpListener.IsSupported) {
return false;
}
var listener = new HttpListener();
var address = "http://localhost:8008/";
listener.Prefixes.Add(address);
listener.Start();
Console.WriteLine("Serving on " + address);
while (true) {
var context = listener.GetContext();
var request = context.Request;
var response = context.Response;
var content = new StreamReader(request.InputStream, request.ContentEncoding).ReadToEnd();
var input = new InputContext();
var responseText = "";
try {
if (!input.Compile(new List<Input> { new Input("<input>", content) })) {
responseText = input.GenerateLog();
} else {
var output = new OutputContext(input);
output.ShouldMinify = request.QueryString["minify"] == "true";
output.ShouldMangle = request.QueryString["mangle"] == "true";
output.SourceMap = request.QueryString["sourceMap"] == "true" ? SourceMap.Inline : SourceMap.None;
responseText = output.Code;
}
} catch (Exception error) {
responseText = error.Message + "\n" + error.StackTrace;
}
var buffer = Encoding.UTF8.GetBytes(responseText);
response.Headers["Access-Control-Allow-Origin"] = "*";
response.ContentLength64 = buffer.Length;
try {
response.OutputStream.Write(buffer, 0, buffer.Length);
} catch (IOException) {
}
response.OutputStream.Close();
}
}
public override void CodeGen(OutputContext output)
{
output.PrintNumber(Value);
}
public AdoCalculatedFieldUpdater(OutputContext context, Process parent, IConnectionFactory cf)
{
_context = context;
_parent = parent;
_cf = cf;
}
public SqlEntityController(OutputContext context, IAction initializer) {
_context = context;
_initializer = initializer;
StartVersion = null;
_stopWatch = new Stopwatch();
}
//public override Type[] ExplicitNodeTypes
//{ get { return new Type[] { typeof(T) }; } }
public virtual IEnumerable <SyntaxTrivia> BuildSyntaxTrivia(IDom item, OutputContext context)
{
throw new NotImplementedException();
}
public SqlStarParametersReader(OutputContext output, Process process) {
_output = output;
_process = process;
_rowCreator = new SqlRowCreator(output);
}
public DelimitedFileWriter(OutputContext context, string fileName = null)
{
_context = context;
_fileName = fileName;
}
public static void ExportFileName(Asset asset, OutputContext context)
{
}
protected override void Load(ContainerBuilder builder)
{
if (_process == null)
{
return;
}
var calc = _process.ToCalculatedFieldsProcess();
var entity = calc.Entities.First();
// I need a process keyed pipeline
builder.Register(ctx => {
var context = new PipelineContext(ctx.Resolve <IPipelineLogger>(), calc, entity);
var outputContext = new OutputContext(context, new Incrementer(context));
IPipeline pipeline;
context.Debug(() => string.Format("Registering {0} pipeline.", _process.Pipeline));
switch (_process.Pipeline)
{
case "parallel.linq":
pipeline = new ParallelPipeline(new DefaultPipeline(ctx.Resolve <IOutputController>(), context));
break;
default:
pipeline = new DefaultPipeline(ctx.Resolve <IOutputController>(), context);
break;
}
// no updater necessary
pipeline.Register(new NullUpdater(context, false));
if (!_process.CalculatedFields.Any())
{
pipeline.Register(new NullReader(context, false));
pipeline.Register(new NullWriter(context, false));
return(pipeline);
}
// register transforms
pipeline.Register(new DefaultTransform(new PipelineContext(ctx.Resolve <IPipelineLogger>(), calc, entity), entity.CalculatedFields));
pipeline.Register(TransformFactory.GetTransforms(ctx, calc, entity, entity.CalculatedFields));
pipeline.Register(new StringTruncateTransfom(new PipelineContext(ctx.Resolve <IPipelineLogger>(), calc, entity)));
// register input and output
switch (outputContext.Connection.Provider)
{
case "sqlserver":
pipeline.Register(ctx.Resolve <IRead>());
pipeline.Register(ctx.Resolve <IWrite>());
pipeline.Register(new MinDateTransform(new PipelineContext(ctx.Resolve <IPipelineLogger>(), calc, entity), new DateTime(1753, 1, 1)));
break;
case "mysql":
case "postgresql":
case "sqlite":
pipeline.Register(ctx.Resolve <IRead>());
pipeline.Register(ctx.Resolve <IWrite>());
break;
default:
pipeline.Register(new NullReader(context));
pipeline.Register(new NullWriter(context));
break;
}
return(pipeline);
}).As <IPipeline>();
}
public static void ExportUrl(Asset asset, OutputContext context)
{
}
private List<ClientSiteRootInfo> FindAllowedSiteRoots(OutputContext context)
{
var instances = new List<ClientSiteRootInfo>();
foreach (var groupName in context.UserInfo.GetGroupNames())
{
if (groupName.ToLowerInvariant().Contains("-view-"))
{
var clientName = groupName.Substring(0, groupName.IndexOf("-")).Trim();
var assetIdString = groupName.Substring(groupName.LastIndexOf("-") + 1).Trim();
var assetId = -1;
if (Int32.TryParse(assetIdString, out assetId))
{
instances.Add(new ClientSiteRootInfo(clientName, assetId));
}
}
}
return instances;
}
public static void RenderOutput(Asset asset, OutputContext context)
{
var xmlFilePath = asset.Raw["local_file"];
RenderOutput(asset, context, xmlFilePath, false);
}
public JsonFileWriter(OutputContext context)
{
_context = context;
_streamWriter = new StreamWriter(new MemoryStream());
_jsonStreamWriter = new JsonStreamWriter(context, _streamWriter);
}
private async Task <ActionResult <DialogFlowResponseDTO> > HandleConsumeElectricityIntent(DialogFlowRequestDTO request)
{
try
{
Parameters parameters = request.queryResult.outputContexts
.FirstOrDefault(oc => oc.name.EndsWith("consume-electricity-output-context"))
.parameters;
var nowUTC = DateTime.Now.ToUniversalTime();
var now = TimeZoneInfo.ConvertTime(nowUTC, _copenhagenTimeZoneInfo);
DateTime finishNoLaterThanUTC;
if (parameters.time != DateTime.MinValue && parameters.date != DateTime.MinValue)
{
DateTime byTime = parameters.time.ToUniversalTime();
DateTime byDate = parameters.time.Date;
finishNoLaterThanUTC = new DateTime(byDate.Year, byDate.Month, byDate.Day, byTime.Hour, byTime.Minute, byTime.Second, DateTimeKind.Utc);
}
else
{
finishNoLaterThanUTC = now.AddDays(1).Date.AddHours(6).ToUniversalTime();
if ((finishNoLaterThanUTC - nowUTC).TotalHours < 6)
{
finishNoLaterThanUTC = finishNoLaterThanUTC.AddDays(1);
}
}
if (parameters.duration == null)
{
if (parameters.devicetype != null)
{
parameters.duration = LookupDefaultDeviceDuration(parameters.devicetype);
}
else
{
parameters.duration = new Duration {
amount = 1, unit = "h"
};
}
}
var prognosis = await PrognosisClient.OptimalConsumptionTimeAsync("DK1", parameters.duration.toHours(), DateTimeOffset.UtcNow.ToString("o"), finishNoLaterThanUTC.ToString("o"));
// var best = await PrognosisClient.OptimalConsumptionTimeAsync(
// consumptionMinutes: parameters.duration.toMinutes(),
// consumptionRegion: "DK1",
// startNoEarlierThan: nowUTC,
// finishNoLaterThan: finishNoLaterThanUTC
// );
if (prognosis != null)
{
DialogFlowResponseDTO response = new DialogFlowResponseDTO();
response.outputContexts = request.queryResult.outputContexts;
var optimalConsumptionStart = TimeZoneInfo.ConvertTime(prognosis.Best.StartUTC, _copenhagenTimeZoneInfo);
var prognosisEnd = TimeZoneInfo.ConvertTime(prognosis.PrognosisEndUTC, _copenhagenTimeZoneInfo).AddMinutes(5);
var prognosisLookaheadHours = Math.Round((prognosis.PrognosisEndUTC - nowUTC).TotalHours, 0);
var finishNoLaterThan = TimeZoneInfo.ConvertTime(finishNoLaterThanUTC, _copenhagenTimeZoneInfo);
var lang = request.queryResult.languageCode;
var culture = CultureInfo.CreateSpecificCulture(lang);
double savingsPercentage = (prognosis.Earliest.Emissions - prognosis.Best.Emissions) / prognosis.Earliest.Emissions;
OutputContext ctx = response.outputContexts
.Find(oc => oc.name.EndsWith("consumeelectricity-followup"));
ctx.parameters.prognosisend = prognosis.PrognosisEndUTC;
ctx.parameters.savingspercentage = (float)Math.Round(savingsPercentage * 100, 0);
ctx.parameters.optimalemissions = Math.Round(prognosis.Best.Emissions, 0);
ctx.parameters.initialemissions = Math.Round(prognosis.Earliest.Emissions, 0);
ctx.parameters.lastEmissions = Math.Round(prognosis.Latest.Emissions, 0);
ctx.parameters.optimalconsumptionstart = optimalConsumptionStart.ToString("dddd HH:mm", culture);
ctx.parameters.finishnolaterthan = finishNoLaterThan.ToString("dddd HH:mm", culture);
ctx.parameters.readableduration = parameters.duration.toReadableString();
ctx.parameters.waitinghours = Math.Round((prognosis.Best.StartUTC - nowUTC).TotalHours, 0);
// ctx.parameters.test1 = optimalConsumptionStart.ToUniversalTime().ToString("o");
// ctx.parameters.test2 = best.optimalConsumptionStart.ToUniversalTime().ToString("o");
if (ctx.parameters.savingspercentage < 2)
{
response.fulfillmentText = "Now is a good time! Do you want to know why?"
.Replace("$device", ctx.parameters.devicetype)
.Replace("$duration", parameters.duration.toReadableString());
}
else
{
response.fulfillmentText = request.queryResult.fulfillmentText
.Replace("$optimalEmissions", ctx.parameters.optimalemissions.ToString())
.Replace("$consumption-start", ctx.parameters.optimalconsumptionstart)
.Replace("$prognosis-end", prognosisEnd.ToString("dddd HH:mm", culture))
.Replace("$savingspercentage", ctx.parameters.savingspercentage.ToString())
.Replace("$prognosislookaheadhours", prognosisLookaheadHours.ToString() + " hours")
.Replace("$finishnolaterthan", ctx.parameters.finishnolaterthan)
.Replace("$readableduration", ctx.parameters.readableduration)
.Replace("$waitinghours", ctx.parameters.waitinghours.ToString());
}
return(response);
}
else
{
_logger.LogError("Received null return value from OptimalFutureConsumptionTime");
return(StatusCode(StatusCodes.Status500InternalServerError));
}
}
catch (Exception ex)
{
_logger.LogError(ex, ex.Message);
return(StatusCode(StatusCodes.Status500InternalServerError));
}
}
/// <summary>
///
/// </summary>
/// <param name="parentContextInStack">parent context in the stack, it can be null</param>
internal OutputContext(OutputContext parentContextInStack)
{
ParentContext = parentContextInStack;
}
public LogWriter(OutputContext context)
{
_context = context;
_level = context.OutputFields.First(f => f.Alias.Equals("level", StringComparison.OrdinalIgnoreCase));
_message = context.OutputFields.First(f => f.Alias.Equals("message", StringComparison.OrdinalIgnoreCase));
}
public SqlEntityInitializer(OutputContext context) {
_context = context;
_connectionString = _context.Process.Connections.First(c => c.Name == "output").GetConnectionString();
}
public override void CodeGen(OutputContext output)
{
output.Print("NaN");
}
public static void RenderUrl(Asset asset, OutputContext context)
{
context.PublishUrl = "";
}
/// <summary>
/// </summary>
/// <param name="parentContextInStack">Parent context in the stack, it can be null.</param>
internal OutputContext(OutputContext parentContextInStack)
{
ParentContext = parentContextInStack;
}
public static void ExportPreview(Asset asset, OutputContext context)
{
}
/// <summary>
/// Process an object from an input stream. It manages the context stack and
/// calls back on the specified event delegates.
/// </summary>
/// <param name="o">Object to process.</param>
internal void Process(object o)
{
PacketInfoData formatData = o as PacketInfoData;
FormatEntryData fed = formatData as FormatEntryData;
if (fed != null)
{
OutputContext ctx = null;
if (!fed.outOfBand)
{
ctx = _stack.Peek();
}
// notify for Payload
this.payload(fed, ctx);
}
else
{
bool formatDataIsFormatStartData = formatData is FormatStartData;
bool formatDataIsGroupStartData = formatData is GroupStartData;
// it's one of our formatting messages
// we assume for the moment that they are in the correct sequence
if (formatDataIsFormatStartData || formatDataIsGroupStartData)
{
OutputContext oc = this.contextCreation(this.ActiveOutputContext, formatData);
_stack.Push(oc);
// now we have the context properly set: need to notify the
// underlying algorithm to do the start document or group stuff
if (formatDataIsFormatStartData)
{
// notify for Fs
this.fs(oc);
}
else if (formatDataIsGroupStartData)
{
// GroupStartData gsd = (GroupStartData) formatData;
// notify for Gs
this.gs(oc);
}
}
else
{
GroupEndData ged = formatData as GroupEndData;
FormatEndData fEndd = formatData as FormatEndData;
if (ged != null || fEndd != null)
{
OutputContext oc = _stack.Peek();
if (fEndd != null)
{
// notify for Fe, passing the Fe info, before a Pop()
this.fe(fEndd, oc);
}
else if (ged != null)
{
// notify for Fe, passing the Fe info, before a Pop()
this.ge(ged, oc);
}
_stack.Pop();
}
}
}
}
public static void RenderFileName(Asset asset, OutputContext context)
{
// TODO
}
public AdoFlatTableCreator(OutputContext output, IConnectionFactory cf)
{
_output = output;
_cf = cf;
}
public static void RenderOutput(Asset asset, OutputContext context, string xmFilePath, bool allowOverwrite)
{
IhSiteBuilderLog siteLog = new IhSiteBuilderLog();
try
{
switch (asset.Raw["sitebuilder_type"])
{
case "site_build":
//--------------------------------------------
// Build Site
//--------------------------------------------
siteLog.Add("Building new site");
string szFileSource = string.Empty;
switch (asset.Raw["technology_list_option"])
{
case "public":
szFileSource = GetPageSource(asset.Raw["cp_language_type"]);
break;
case "training":
szFileSource = GetPageSource(asset.Raw["training_language_type"]);
break;
case "private":
szFileSource = GetPageSource(asset.Raw["private_language_type"]);
break;
case "local":
siteLog.Add("Building local site from file: " + xmFilePath);
Asset aLocalFile = Asset.Load(xmFilePath);
siteLog.Add("Have local file: " + aLocalFile.IsLoaded.ToString());
if (aLocalFile.IsLoaded)
szFileSource = CTLHelper.GetBinaryAsText(aLocalFile);
else
siteLog.Add("Error - Unable to load file");
break;
}
if (!string.IsNullOrWhiteSpace(szFileSource))
{
string szCollectionPath, szSiteRootName, szProjectName = string.Empty;
if (asset["collection_folder_type"].Equals("new"))
szCollectionPath = "/" + asset["collection_new"];
else
szCollectionPath = Asset.Load(asset["collection_select"]).AssetPath.ToString();
szSiteRootName = asset.Raw["site_root_name"];
szProjectName = asset.Raw["project_name"];
bool bChildProject = false;
if (asset["project_level"].Equals("nested"))
bChildProject = true;
IhSiteBuilderImport.ReplicateSite(asset, szFileSource, szCollectionPath, szSiteRootName, szProjectName, workflowName: asset.Raw["workflow_name"], clientName: context.ClientName, childProject: bChildProject, siteLog: siteLog, allowOverwrite: allowOverwrite);
string szRootName = string.Empty;
siteLog.Add("Builder finished");
}
break;
case "site_extension":
//--------------------------------------------
// Add Extension
//--------------------------------------------
switch (asset.Raw["extension_types"])
{
case "ext_tmf":
//Add TMF
CreateTMF(asset, siteLog);
break;
case "ext_blog":
break;
}
break;
default:
break;
}
}
catch (Exception e)
{
siteLog.Add(e.Message);
}
//Create Log
CreateLogFile(asset, siteLog);
}
public RethinkDbInitializer(InputContext input, OutputContext output, IConnectionFactory connectionFactory)
{
_input = input;
_output = output;
_factory = connectionFactory;
}
public static void ExportOutput(Asset asset, OutputContext context)
{
//TO DO
}
public override void CodeGen(OutputContext output)
{
output.PrintName(MangledName ?? Name);
}
public SqlCalculatedFieldUpdater(OutputContext context, Process original) {
_context = context;
_original = original;
}
public override void WriteOutput(OutputContext context)
{
context.Append(Value);
}
public static int Main(string[] args)
{
var boolFlags = new Dictionary<string, bool> {
{ "--minify", false },
{ "--mangle", false },
{ "--timing", false },
{ "--server", false },
{ "--source-map", false },
};
string outputPath = null;
// Parse command-line arguments
var inputs = new List<Input>();
for (var i = 0; i < args.Length; i++) {
var arg = args[i];
// Help
if (arg == "-h" || arg == "-help" || arg == "--help" || arg == "-?" || arg == "/?") {
WriteUsage();
return 0;
}
// Boolean flags
if (boolFlags.ContainsKey(arg)) {
if (boolFlags[arg]) {
Console.WriteLine("Duplicate flag \"" + arg + "\"");
return 1;
}
boolFlags[arg] = true;
continue;
}
// Output file
if (arg == "--output" || arg == "-o") {
if (outputPath != null) {
Console.WriteLine("Duplicate flag \"" + arg + "\"");
return 1;
}
if (i + 1 == args.Length) {
Console.WriteLine("Missing path for flag \"" + arg + "\"");
return 1;
}
outputPath = args[++i];
continue;
}
// Invalid flags
if (arg.StartsWith("-")) {
Console.WriteLine("Invalid flag \"" + arg + "\"");
return 1;
}
// Input files
inputs.Add(new Input(arg, File.ReadAllText(arg)));
}
// The server option ignores all other options
if (boolFlags["--server"]) {
return RunLocalServer() ? 0 : 1;
}
// Show usage if there are no inputs
if (inputs.Count == 0) {
WriteUsage();
return 1;
}
// Parse inputs
var context = new InputContext();
if (!context.Compile(inputs)) {
Console.Write(context.GenerateLog());
return 1;
}
// Generate output
var output = new OutputContext(context);
output.ShouldMinify = boolFlags["--minify"];
output.ShouldMangle = boolFlags["--mangle"];
output.SourceMap = boolFlags["--source-map"] ? outputPath != null ? SourceMap.External : SourceMap.Inline : SourceMap.None;
if (outputPath != null) {
File.WriteAllText(outputPath, output.Code);
if (output.SourceMap == SourceMap.External) {
File.WriteAllText(outputPath + ".map", output.SourceMapCode);
}
} else {
Console.Write(output.Code);
}
// Write out timing info for debugging
if (boolFlags["--timing"]) {
foreach (var pair in context.timingInMilliseconds) {
Console.Error.WriteLine(pair.Key + ": " + pair.Value + "ms");
}
}
return 0;
}
protected override void Load(ContainerBuilder builder)
{
if (!builder.Properties.ContainsKey("Process"))
{
return;
}
var process = (Process)builder.Properties["Process"];
// connections
foreach (var connection in process.Connections.Where(c => c.Provider == SqlCe))
{
// Connection Factory
builder.Register <IConnectionFactory>(ctx => new SqlCeConnectionFactory(connection)).Named <IConnectionFactory>(connection.Key).InstancePerLifetimeScope();
// Schema Reader
builder.Register <ISchemaReader>(ctx => {
var factory = ctx.ResolveNamed <IConnectionFactory>(connection.Key);
return(new AdoSchemaReader(ctx.ResolveNamed <IConnectionContext>(connection.Key), factory));
}).Named <ISchemaReader>(connection.Key);
}
// entitiy input
foreach (var entity in process.Entities.Where(e => process.Connections.First(c => c.Name == e.Input).Provider == SqlCe))
{
// INPUT READER
builder.Register <IRead>(ctx => {
var input = ctx.ResolveNamed <InputContext>(entity.Key);
var rowFactory = ctx.ResolveNamed <IRowFactory>(entity.Key, new NamedParameter("capacity", input.RowCapacity));
var dataReader = new AdoInputReader(
input,
input.InputFields,
ctx.ResolveNamed <IConnectionFactory>(input.Connection.Key),
rowFactory
);
return(dataReader);
}).Named <IRead>(entity.Key);
// INPUT VERSION DETECTOR
builder.Register <IInputProvider>(ctx => {
var input = ctx.ResolveNamed <InputContext>(entity.Key);
return(new AdoInputProvider(input, ctx.ResolveNamed <IConnectionFactory>(input.Connection.Key)));
}).Named <IInputProvider>(entity.Key);
}
// entity output
if (process.GetOutputConnection().Provider == SqlCe)
{
var calc = process.ToCalculatedFieldsProcess();
// PROCESS OUTPUT CONTROLLER
builder.Register <IOutputController>(ctx => {
var output = ctx.Resolve <OutputContext>();
if (process.Mode != "init")
{
return(new NullOutputController());
}
var actions = new List <IAction> {
new AdoStarViewCreator(output, ctx.ResolveNamed <IConnectionFactory>(output.Connection.Key))
};
if (process.Flatten)
{
actions.Add(new AdoFlatTableCreator(output, ctx.ResolveNamed <IConnectionFactory>(output.Connection.Key)));
}
return(new AdoStarController(output, actions));
}).As <IOutputController>();
// PROCESS CALCULATED READER
builder.Register <IRead>(ctx => {
var calcContext = new PipelineContext(ctx.Resolve <IPipelineLogger>(), calc, calc.Entities.First());
var outputContext = new OutputContext(calcContext);
var cf = ctx.ResolveNamed <IConnectionFactory>(outputContext.Connection.Key);
var capacity = outputContext.Entity.Fields.Count + outputContext.Entity.CalculatedFields.Count;
var rowFactory = new RowFactory(capacity, false, false);
return(new AdoStarParametersReader(outputContext, process, cf, rowFactory));
}).As <IRead>();
// PROCESS CALCULATED FIELD WRITER
builder.Register <IWrite>(ctx => {
var calcContext = new PipelineContext(ctx.Resolve <IPipelineLogger>(), calc, calc.Entities.First());
var outputContext = new OutputContext(calcContext);
var cf = ctx.ResolveNamed <IConnectionFactory>(outputContext.Connection.Key);
return(new AdoCalculatedFieldUpdater(outputContext, process, cf));
}).As <IWrite>();
// PROCESS INITIALIZER
builder.Register <IInitializer>(ctx => {
var output = ctx.Resolve <OutputContext>();
return(new AdoInitializer(output, ctx.ResolveNamed <IConnectionFactory>(output.Connection.Key)));
}).As <IInitializer>();
// ENTITIES
foreach (var entity in process.Entities)
{
builder.Register <IOutputProvider>(ctx => {
var output = ctx.ResolveNamed <OutputContext>(entity.Key);
var cf = ctx.ResolveNamed <IConnectionFactory>(output.Connection.Key);
var rowFactory = ctx.ResolveNamed <IRowFactory>(entity.Key, new NamedParameter("capacity", output.GetAllEntityFields().Count()));
// matcher determines what's an update vs. and insert
var matcher = entity.Update ? (IBatchReader) new AdoEntityMatchingKeysReader(output, cf, rowFactory) : new NullBatchReader();
IWrite writer = new SqlCeWriter(
output,
cf,
matcher,
new AdoEntityUpdater(output, cf)
);
return(new AdoOutputProvider(output, cf, writer));
}).Named <IOutputProvider>(entity.Key);
// ENTITY OUTPUT CONTROLLER
builder.Register <IOutputController>(ctx => {
var output = ctx.ResolveNamed <OutputContext>(entity.Key);
var initializer = process.Mode == "init" ? (IAction) new AdoEntityInitializer(output, ctx.ResolveNamed <IConnectionFactory>(output.Connection.Key)) : new NullInitializer();
return(new AdoOutputController(
output,
initializer,
ctx.ResolveNamed <IInputProvider>(entity.Key),
ctx.ResolveNamed <IOutputProvider>(entity.Key),
ctx.ResolveNamed <IConnectionFactory>(output.Connection.Key)
));
}).Named <IOutputController>(entity.Key);
// MASTER UPDATE QUERY
builder.Register <IWriteMasterUpdateQuery>(ctx => {
var output = ctx.ResolveNamed <OutputContext>(entity.Key);
var factory = ctx.ResolveNamed <IConnectionFactory>(output.Connection.Key);
return(new AdoUpdateMasterKeysQueryWriter(output, factory));
}).Named <IWriteMasterUpdateQuery>(entity.Key + "MasterKeys");
// MASTER UPDATER
builder.Register <IUpdate>(ctx => {
var output = ctx.ResolveNamed <OutputContext>(entity.Key);
return(new AdoTwoPartMasterUpdater(output, ctx.ResolveNamed <IConnectionFactory>(output.Connection.Key)));
}).Named <IUpdate>(entity.Key);
// DELETE HANDLER
if (entity.Delete)
{
// register input keys and hashcode reader if necessary
builder.Register(ctx => {
var inputContext = ctx.ResolveNamed <InputContext>(entity.Key);
var rowCapacity = inputContext.Entity.GetPrimaryKey().Count();
var rowFactory = new RowFactory(rowCapacity, false, true);
return(new AdoReader(
inputContext,
entity.GetPrimaryKey(),
ctx.ResolveNamed <IConnectionFactory>(inputContext.Connection.Key),
rowFactory,
ReadFrom.Input
));
}).Named <IReadInputKeysAndHashCodes>(entity.Key);
// register output keys and hash code reader if necessary
builder.Register((ctx => {
var context = ctx.ResolveNamed <OutputContext>(entity.Key);
var rowCapacity = context.Entity.GetPrimaryKey().Count();
var rowFactory = new RowFactory(rowCapacity, false, true);
var outputConnection = process.GetOutputConnection();
var ocf = ctx.ResolveNamed <IConnectionFactory>(outputConnection.Key);
return(new AdoReader(context, entity.GetPrimaryKey(), ocf, rowFactory, ReadFrom.Output));
})).Named <IReadOutputKeysAndHashCodes>(entity.Key);
builder.Register((ctx) => {
var outputConnection = process.GetOutputConnection();
var outputContext = ctx.ResolveNamed <OutputContext>(entity.Key);
var ocf = ctx.ResolveNamed <IConnectionFactory>(outputConnection.Key);
return(new AdoDeleter(outputContext, ocf));
}).Named <IDelete>(entity.Key);
builder.Register <IEntityDeleteHandler>(ctx => {
var context = ctx.ResolveNamed <IContext>(entity.Key);
var primaryKey = entity.GetPrimaryKey();
var handler = new DefaultDeleteHandler(
context,
ctx.ResolveNamed <IReadInputKeysAndHashCodes>(entity.Key),
ctx.ResolveNamed <IReadOutputKeysAndHashCodes>(entity.Key),
ctx.ResolveNamed <IDelete>(entity.Key)
);
// since the primary keys from the input may have been transformed into the output, you have to transform before comparing
// feels a lot like entity pipeline on just the primary keys... may look at consolidating
handler.Register(new DefaultTransform(context, entity.GetPrimaryKey().ToArray()));
handler.Register(TransformFactory.GetTransforms(ctx, context, primaryKey));
handler.Register(new StringTruncateTransfom(context, primaryKey));
return(handler);
}).Named <IEntityDeleteHandler>(entity.Key);
}
}
}
}
