public void ReturnsNullableEnumValuesViaValue()
{
var rdr = new Mock <IDataReader>();
rdr.Setup(r => r.GetFieldType(0)).Returns(typeof(int));
rdr.SetupSequence(r => r.IsDBNull(0))
.Returns(false)
.Returns(true)
.Returns(false)
.Returns(false);
rdr.SetupSequence(r => r.GetInt32(0))
.Returns(1)
.Returns(2)
.Returns(0);
rdr.SetupSequence(r => r.Read())
.Returns(true)
.Returns(true)
.Returns(true)
.Returns(true)
.Returns(false);
var toTest = RowFactory <IntEnum?> .Create();
toTest.ParseRows(rdr.Object, Enumerable.Empty <IDataTransformer>(), CancellationToken.None)
.Should().ContainInOrder(IntEnum.One, null, IntEnum.Two, IntEnum.Zero);
}
public void ReturnsNullableEnumValuesViaBoxedValue()
{
var rdr = new Mock <IDataReader>();
rdr.Setup(r => r.GetFieldType(0)).Returns(typeof(int));
rdr.SetupSequence(r => r.IsDBNull(0))
.Returns(false)
.Returns(true)
.Returns(false)
.Returns(false);
rdr.SetupSequence(r => r.GetValue(0))
.Returns(-1)
.Returns(2)
.Returns(0);
rdr.SetupSequence(r => r.Read())
.Returns(true)
.Returns(true)
.Returns(true)
.Returns(true)
.Returns(false);
var toTest = RowFactory <IntEnum?> .Create();
var xf = new Mock <IDataTransformer>();
xf.Setup(x => x.CanTransform(-1, typeof(IntEnum), true, It.Is <IEnumerable <Attribute> >(attrs => attrs != null)))
.Returns(true);
xf.Setup(x => x.Transform(-1, typeof(IntEnum), true, It.Is <IEnumerable <Attribute> >(attrs => attrs != null)))
.Returns(1);
toTest.ParseRows(rdr.Object, new[] { xf.Object }, CancellationToken.None)
.Should().ContainInOrder(IntEnum.One, null, IntEnum.Two, IntEnum.Zero);
}
public async Task ReturnsNullableEnumValuesViaName()
{
var rdr = new Mock <DbDataReader>();
rdr.Setup(r => r.GetFieldType(0)).Returns(typeof(string));
rdr.SetupSequence(r => r.IsDBNull(0))
.Returns(false)
.Returns(true)
.Returns(false)
.Returns(false);
rdr.SetupSequence(r => r.GetString(0))
.Returns("One")
.Returns("Two")
.Returns("Zero");
rdr.SetupSequence(r => r.ReadAsync(It.IsAny <CancellationToken>()))
.ReturnsAsync(true)
.ReturnsAsync(true)
.ReturnsAsync(true)
.ReturnsAsync(true)
.ReturnsAsync(false);
var toTest = RowFactory <IntEnum?> .Create();
var res = await toTest.ParseRowsAsync(rdr.Object, Enumerable.Empty <IDataTransformer>(), CancellationToken.None);
res.Should().ContainInOrder(IntEnum.One, null, IntEnum.Two, IntEnum.Zero);
}
public void GetTypedDataSet()
{
var cfg = new FileReader().Read(@"Files\PersonAndPet.xml", null, new Cfg.Net.Loggers.NullLogger());
var sh = new ShorthandRoot(@"Files\Shorthand.xml", new FileReader());
var process = new Process(cfg, new JintValidator("js"), new ShorthandModifier(sh, "sh"));
var personContext = new PipelineContext(new DebugLogger(), process, process.Entities.Last());
var entityInput = new InputContext(personContext, new Incrementer(personContext));
var rowFactory = new RowFactory(entityInput.RowCapacity, entityInput.Entity.IsMaster, false);
var rows = new InternalReader(entityInput, rowFactory).Read().ToArray();
Assert.IsInstanceOf <IEnumerable <IRow> >(rows);
Assert.AreEqual(3, rows.Length);
var dale = rows[0];
var micheal = rows[1];
Assert.IsInstanceOf <int>(dale[FieldAt(4)]);
Assert.AreEqual(1, dale[FieldAt(4)]);
Assert.AreEqual("Dale", dale[FieldAt(5)]);
Assert.AreEqual("Michael", micheal[FieldAt(5)]);
foreach (var row in rows)
{
Console.WriteLine(row);
}
}
public void ReturnsNullableEnumValuesViaNameTransformsBeforeParsing_WithGlobalTransformer()
{
using (GlobalSettings.UseTestInstance())
{
var rdr = new Mock <IDataReader>();
rdr.Setup(r => r.GetFieldType(0)).Returns(typeof(string));
rdr.SetupSequence(r => r.IsDBNull(0))
.Returns(false)
.Returns(true)
.Returns(false)
.Returns(false);
rdr.SetupSequence(r => r.GetString(0))
.Returns("Blah")
.Returns("Two")
.Returns("Zero");
rdr.SetupSequence(r => r.Read())
.Returns(true)
.Returns(true)
.Returns(true)
.Returns(true)
.Returns(false);
var toTest = RowFactory <IntEnum?> .Create();
var xf = new Mock <IDataTransformer>();
xf.Setup(x => x.CanTransform("Blah", typeof(IntEnum), true, It.Is <IEnumerable <Attribute> >(attrs => attrs != null)))
.Returns(true);
xf.Setup(x => x.Transform("Blah", typeof(IntEnum), true, It.Is <IEnumerable <Attribute> >(attrs => attrs != null)))
.Returns("One");
StoredProcedure.AddGlobalTransformer(xf.Object);
toTest.ParseRows(rdr.Object, new IDataTransformer[0], CancellationToken.None)
.Should().ContainInOrder(IntEnum.One, null, IntEnum.Two, IntEnum.Zero);
}
}
protected override void Load(ContainerBuilder builder)
{
if (_process == null)
{
return;
}
if (_process.Connections.All(c => c.Provider != Internal))
{
return;
}
// add null schema reader for each internal connection
foreach (var connection in _process.Connections.Where(c => c.Provider == Internal))
{
builder.RegisterType <NullSchemaReader>().Named <ISchemaReader>(connection.Key);
}
// PROCESS AND ENTITY OUTPUT
// if output is internal, setup internal output controllers for the process and each entity
if (_process.GetOutputConnection().Provider == Internal)
{
// PROCESS OUTPUT CONTROLLER
builder.Register <IOutputController>(ctx => new NullOutputController()).As <IOutputController>();
foreach (var entity in _process.Entities)
{
builder.Register <IOutputController>(ctx => new NullOutputController()).Named <IOutputController>(entity.Key);
builder.Register <IOutputProvider>(ctx => new InternalOutputProvider(ctx.ResolveNamed <OutputContext>(entity.Key), ctx.ResolveNamed <IWrite>(entity.Key))).Named <IOutputProvider>(entity.Key);
// WRITER
builder.Register <IWrite>(ctx => new InternalWriter(ctx.ResolveNamed <OutputContext>(entity.Key))).Named <IWrite>(entity.Key);
}
}
// ENTITY INPUT
// setup internal input readers for each entity if necessary
foreach (var entity in _process.Entities.Where(e => _process.Connections.First(c => c.Name == e.Input).Provider == Internal))
{
builder.RegisterType <NullInputProvider>().Named <IInputProvider>(entity.Key);
// handling internal deletes
if (entity.Delete)
{
builder.Register <IReadInputKeysAndHashCodes>(ctx => {
// note: i tried to just load keys but had a lot of troubles, this works (for now).
var inputContext = ctx.ResolveNamed <InputContext>(entity.Key);
var rowFactory = new RowFactory(inputContext.RowCapacity, entity.IsMaster, false);
return(new InternalKeysReader(new InternalReader(inputContext, rowFactory)));
}).Named <IReadInputKeysAndHashCodes>(entity.Key);
}
// READER
builder.Register <IRead>(ctx => {
var input = ctx.ResolveNamed <InputContext>(entity.Key);
var rowFactory = ctx.ResolveNamed <IRowFactory>(entity.Key, new NamedParameter("capacity", input.RowCapacity));
return(new InternalReader(input, rowFactory));
}).Named <IRead>(entity.Key);
}
}
private void ModifyFields(IEnumerable <Field> fields)
{
var expanded = fields.ToArray();
if (_context.Connection.MaxLength > 0)
{
foreach (var field in expanded)
{
field.Length = _context.Connection.MaxLength.ToString();
}
}
var checkLength = _context.Connection.MinLength > 0 || _context.Connection.MaxLength > 0;
var checkTypes = _context.Connection.Types.Any(t => t.Type != "string");
if (checkTypes || checkLength)
{
var entity = _process.Entities.First();
var rowFactory = new RowFactory(_context.RowCapacity, entity.IsMaster, false);
var reader = new DelimitedFileReader(_context, rowFactory);
var defaultTransform = new Transforms.System.DefaultTransform(new PipelineContext(_context.Logger, _process, entity), entity.GetAllFields());
var rows = defaultTransform.Operate(reader.Read()).ToArray(); // can take a lot of memory
if (rows.Length == 0)
{
return;
}
if (checkLength)
{
Parallel.ForEach(expanded, f => {
var length = _context.Connection.MaxLength == 0 ? rows.Max(row => row[f].ToString().Length) + 1 : Math.Min(rows.Max(row => row[f].ToString().Length) + 1, _context.Connection.MaxLength);
if (_context.Connection.MinLength > 0 && length < _context.Connection.MinLength)
{
length = _context.Connection.MinLength;
}
f.Length = length.ToString();
});
}
if (checkTypes)
{
var canConvert = Constants.CanConvert();
Parallel.ForEach(expanded, f => {
foreach (var dataType in _context.Connection.Types.Where(t => t.Type != "string"))
{
if (rows.All(r => canConvert[dataType.Type](r[f].ToString())))
{
f.Type = dataType.Type;
break;
}
}
});
}
}
}
public static LinkedList <Row> ToRowEntityList(this WorkSheet worksheet)
{
LinkedList <Row> rowList = new LinkedList <Row>();
for (int i = 1; i < worksheet.RowCount; i++)
{
RangeRow row = worksheet.GetRow(i);
rowList.AddLast(RowFactory.CreateRowFromCells(row.ToArray()));
}
return(rowList);
}
private void CreateUnits()
{
var boxFactory = new BoxFactory();
var columnFactory = new ColumnFactory();
var rowFactory = new RowFactory();
for (int i = 0; i < 9; i++)
{
_boxes[i] = boxFactory.Factory(_cells, i);
_columns[i] = columnFactory.Factory(_cells, i);
_rows[i] = rowFactory.Factory(_cells, i);
}
}
public void ParsesNullableDoubleAsNull()
{
var rdr = new Mock <IDataReader>();
rdr.Setup(r => r.GetFieldType(0)).Returns(typeof(double));
rdr.Setup(r => r.IsDBNull(0)).Returns(true);
rdr.SetupSequence(r => r.Read())
.Returns(true)
.Returns(false);
var toTest = RowFactory <double?> .Create();
toTest.ParseRows(rdr.Object, Enumerable.Empty <IDataTransformer>(), CancellationToken.None)
.Single().Should().Be(default(Nullable <double>));
}
public bool MatchesColumns(IEnumerable <string> columnNames, out int unMatchedColumnCount)
{
var success = RowFactory.MatchesColumns(columnNames, out unMatchedColumnCount);
if (!string.IsNullOrEmpty(ParentKeyColumnName) && columnNames.Contains(ParentKeyColumnName))
{
--unMatchedColumnCount;
}
if (!string.IsNullOrEmpty(ItemKeyColumnName) && columnNames.Contains(ItemKeyColumnName))
{
--unMatchedColumnCount;
}
return(success);
}
private void DoWorkAndReport(IProducerConsumerCollection <object[]> input, IProducerConsumerCollection <Row> output, ManualResetEvent pauseEvent, IProgress <int> progressMonitor)
{
RowFactory Factory = new RowFactory(ColumnNames);
int ExpectedColumnCount = ColumnNames.Count();
int processedCount = 0;
while (HasWork)
{
pauseEvent.WaitOne();
object[] currentInput;
if (input.TryTake(out currentInput))
{
if (ExpectedColumnCount != currentInput.Count())
{
var errorMsg = $"A row was skipped over because it had too many or too few columns, expected: {ExpectedColumnCount}, actual: {currentInput.Count()}";
if (IsSkippingError)
{
LogService.Instance.Warn(errorMsg);
}
else
{
Exception ex = new Exception(errorMsg);
LogService.Instance.Error(ex);
throw ex;
}
}
else
{
Row newRow = Factory.CreateRow(currentInput);
while (!output.TryAdd(newRow))
{
pauseEvent.WaitOne();
}
processedCount++;
}
}
else
{
Thread.Sleep(10);
}
if (processedCount % 1000 == 0)
{
progressMonitor.Report(processedCount);
}
}
progressMonitor.Report(processedCount);
}
private static void Assert <T, TFactory>(string typeName = null)
where TFactory : IRowFactory <T>
{
if (typeName == null)
{
typeName = typeof(T).Name;
}
var result = RowFactory <T> .Create();
var typeF = typeof(TFactory);
var factoryName = typeF.Name.Substring(0, typeF.Name.Length - 2); // get rid of the `1
result.Should().NotBeNull("result should not be null");
result.RowType.Should().BeSameAs(typeof(T), "result should have RowType set to {0}", typeName);
result.Should().BeOfType <TFactory>("result should be of type {0}<{1}>", factoryName, typeName);
}
public void CreateRowTest()
{
string[] columns = new string[] { "AnInteger", "AString", "ADouble", "ADate" };
RowFactory Factory = new RowFactory(columns);
int AnInteger = 5;
string AString = "Number 1 sister";
double ADouble = 3.50d;
DateTime ADate = DateTime.Now;
object[] Record = new object[] { AnInteger, AString, ADouble, ADate };
Row MyRow = Factory.CreateRow(Record);
Console.WriteLine(JsonConvert.SerializeObject(MyRow));
for (int i = 0; i < 4; i++)
{
//check types
Assert.AreEqual(expected: Record[i].GetType(), actual: MyRow[columns[i]].Item2);
//check values
Assert.AreEqual(expected: Record[i], actual: MyRow[columns[i]].Item1);
}
Record = new object[] { "haha" };
bool errorThrown = false;
try
{
MyRow = Factory.CreateRow(Record);
}
catch (Exception ex)
{
// if we reach here its good
errorThrown = true;
}
finally
{
if (!errorThrown)
{
Assert.Fail();
}
}
}
/// <summary>
/// TestReader has to account for 4 system fields that are present
/// </summary>
/// <param name="entity"></param>
/// <returns></returns>
private static TestReader GetTestReader(Entity entity)
{
var capacity = entity.GetAllFields().Count();
var rowFactory = new RowFactory(capacity, false, false);
var row1 = rowFactory.Create();
row1[entity.Fields[0]] = 1;
row1[entity.Fields[1]] = "One";
var row2 = rowFactory.Create();
row2[entity.Fields[0]] = 2;
row2[entity.Fields[1]] = "Two";
var data = new List <IRow> {
row1, row2
};
return(new TestReader(data));
}
private IEnumerable <T> GetResults <T>(bool isSingle)
{
if (resultTask == null)
{
throw new NotSupportedException("When calling the dynamic syntax with a NonQuery variant, no results are returned, so the value can not be cast to a result set.");
}
try
{
return(RowFactory <T> .Create(isSingle).ParseRows(resultTask.Result, transformers, token));
}
finally
{
if (isSingle)
{
ReadToEnd();
resultTask.Result.Dispose();
}
}
}
protected override void Load(ContainerBuilder builder)
{
if (_process == null)
{
return;
}
// connections
foreach (var connection in _process.Connections.Where(c => _ado.Contains(c.Provider)))
{
var cn = connection;
// Connection Factory
builder.Register <IConnectionFactory>(ctx => {
switch (cn.Provider)
{
case "sqlserver":
return(new SqlServerConnectionFactory(cn));
case "mysql":
return(new MySqlConnectionFactory(cn));
default:
return(new NullConnectionFactory());
}
}).Named <IConnectionFactory>(connection.Key).InstancePerLifetimeScope();
// Schema Reader
builder.Register <ISchemaReader>(ctx => {
var factory = ctx.ResolveNamed <IConnectionFactory>(cn.Key);
return(new AdoSchemaReader(ctx.ResolveNamed <IConnectionContext>(cn.Key), factory));
}).Named <ISchemaReader>(connection.Key);
}
//ISchemaReader
//IOutputController
//IRead (Process for Calculated Columns)
//IWrite (Process for Calculated Columns)
//IInitializer (Process)
// Per Entity
// IInputVersionDetector
// IRead (Input, per Entity)
// IOutputController
// -- IBatchReader (for matching)
// -- IWriteMasterUpdateQuery (for updating)
// IUpdate
// IWrite
// IEntityDeleteHandler
// entitiy input
foreach (var entity in _process.Entities.Where(e => _ado.Contains(_process.Connections.First(c => c.Name == e.Connection).Provider)))
{
// INPUT READER
builder.Register(ctx => {
var input = ctx.ResolveNamed <InputContext>(entity.Key);
var rowFactory = ctx.ResolveNamed <IRowFactory>(entity.Key, new NamedParameter("capacity", input.RowCapacity));
IRead dataReader;
switch (input.Connection.Provider)
{
case "mysql":
case "sqlserver":
dataReader = new AdoInputReader(
input,
input.InputFields,
ctx.ResolveNamed <IConnectionFactory>(input.Connection.Key),
rowFactory
);
break;
default:
dataReader = new NullReader(input, false);
break;
}
// "form" mode support if filter on primary key exists
if (_process.Mode == "form" && entity.GetPrimaryKey().Any() && entity.GetPrimaryKey().All(f => entity.Filter.Any(i => i.Field == f.Alias || i.Field == f.Name)))
{
if (entity.GetPrimaryKey().All(pk => entity.Filter.First(i => i.Field == pk.Alias || i.Field == pk.Name).Value == (pk.Default == Constants.DefaultSetting ? Constants.StringDefaults()[pk.Type] : pk.Default)))
{
// primary key is default, don't read from database
return(new ParameterRowReader(input, new DefaultRowReader(input, rowFactory)));
}
// read from database and update with parameters, otherwise just return the data reader
if (HttpContext.Current.Request.HttpMethod == "POST")
{
return(new ParameterRowReader(input, dataReader, rowFactory));
}
}
return(dataReader);
}).Named <IRead>(entity.Key);
// INPUT VERSION DETECTOR
builder.Register <IInputProvider>(ctx => {
var input = ctx.ResolveNamed <InputContext>(entity.Key);
switch (input.Connection.Provider)
{
case "mysql":
case "sqlserver":
return(new AdoInputProvider(input, ctx.ResolveNamed <IConnectionFactory>(input.Connection.Key)));
default:
return(new NullInputProvider());
}
}).Named <IInputProvider>(entity.Key);
}
// entity output
if (_ado.Contains(_process.Output().Provider))
{
var calc = _process.ToCalculatedFieldsProcess();
// PROCESS OUTPUT CONTROLLER
builder.Register <IOutputController>(ctx => {
var output = ctx.Resolve <OutputContext>();
if (_process.Mode != "init")
{
return(new NullOutputController());
}
switch (output.Connection.Provider)
{
case "mysql":
case "sqlserver":
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));
default:
return(new NullOutputController());
}
}).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 e in _process.Entities)
{
var entity = e;
// WRITER
builder.Register <IWrite>(ctx => {
var output = ctx.ResolveNamed <OutputContext>(entity.Key);
var cf = ctx.ResolveNamed <IConnectionFactory>(output.Connection.Key);
switch (output.Connection.Provider)
{
case "sqlserver":
return(new SqlServerWriter(
output,
cf,
ctx.ResolveNamed <IBatchReader>(entity.Key),
new AdoEntityUpdater(output, cf)
));
case "mysql":
return(new AdoEntityWriter(
output,
ctx.ResolveNamed <IBatchReader>(entity.Key),
new AdoEntityInserter(output, cf),
entity.Update ? (IWrite) new AdoEntityUpdater(output, cf) : new NullWriter(output)
));
default:
return(new NullWriter(output));
}
}).Named <IWrite>(entity.Key);
builder.Register <IOutputProvider>(ctx => {
var output = ctx.ResolveNamed <OutputContext>(entity.Key);
return(new AdoOutputProvider(output, ctx.ResolveNamed <IConnectionFactory>(output.Connection.Key), ctx.ResolveNamed <IWrite>(entity.Key)));
}).Named <IOutputProvider>(entity.Key);
// ENTITY OUTPUT CONTROLLER
builder.Register <IOutputController>(ctx => {
var output = ctx.ResolveNamed <OutputContext>(entity.Key);
switch (output.Connection.Provider)
{
case "mysql":
case "sqlserver":
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)
));
default:
return(new NullOutputController());
}
}).Named <IOutputController>(entity.Key);
// OUTPUT ROW MATCHER
builder.Register <IBatchReader>(ctx => {
if (!entity.Update)
{
return(new NullBatchReader());
}
var output = ctx.ResolveNamed <OutputContext>(entity.Key);
var rowFactory = ctx.ResolveNamed <IRowFactory>(entity.Key, new NamedParameter("capacity", output.GetAllEntityFields().Count()));
var cf = ctx.ResolveNamed <IConnectionFactory>(output.Connection.Key);
return(new AdoEntityMatchingKeysReader(output, cf, rowFactory));
}).Named <IBatchReader>(entity.Key);
// MASTER UPDATE QUERY
builder.Register <IWriteMasterUpdateQuery>(ctx => {
var output = ctx.ResolveNamed <OutputContext>(entity.Key);
var factory = ctx.ResolveNamed <IConnectionFactory>(output.Connection.Key);
switch (output.Connection.Provider)
{
case "mysql":
return(new MySqlUpdateMasterKeysQueryWriter(output, factory));
default:
return(new SqlServerUpdateMasterKeysQueryWriter(output, factory));
}
}).Named <IWriteMasterUpdateQuery>(entity.Key + "MasterKeys");
// MASTER UPDATER
builder.Register <IUpdate>(ctx => {
var output = ctx.ResolveNamed <OutputContext>(entity.Key);
switch (output.Connection.Provider)
{
case "mysql":
case "postgresql":
case "sqlserver":
return(new AdoMasterUpdater(
output,
ctx.ResolveNamed <IConnectionFactory>(output.Connection.Key),
ctx.ResolveNamed <IWriteMasterUpdateQuery>(entity.Key + "MasterKeys")
));
case "sqlite":
case "sqlce":
return(new AdoTwoPartMasterUpdater(output, ctx.ResolveNamed <IConnectionFactory>(output.Connection.Key)));
default:
return(new NullMasterUpdater());
}
}).Named <IUpdate>(entity.Key);
// DELETE HANDLER
if (entity.Delete)
{
builder.Register <IEntityDeleteHandler>(ctx => new NullDeleteHandler()).Named <IEntityDeleteHandler>(entity.Key);
}
}
}
}
protected override void Load(ContainerBuilder builder)
{
if (_process == null)
{
return;
}
// Connections
foreach (var connection in _process.Connections.Where(c => c.Provider == "internal"))
{
builder.RegisterType <NullSchemaReader>().Named <ISchemaReader>(connection.Key);
}
// Entity input
foreach (var entity in _process.Entities.Where(e => _internal.Contains(_process.Connections.First(c => c.Name == e.Connection).Provider)))
{
builder.RegisterType <NullInputProvider>().Named <IInputProvider>(entity.Key);
// Another provider's delete handler may need this if the consumer has swapped moved the input to internal rows for editing (e.g. HandsOnTable in Orchard CMS Module)
if (entity.Delete)
{
builder.Register <IReadInputKeysAndHashCodes>(ctx => {
// note: i tried to just load keys but had a lot of troubles, this works (for now).
var inputContext = ctx.ResolveNamed <InputContext>(entity.Key);
var rowFactory = new RowFactory(inputContext.RowCapacity, entity.IsMaster, false);
return(new InternalKeysReader(new InternalReader(inputContext, rowFactory)));
}).Named <IReadInputKeysAndHashCodes>(entity.Key);
}
// READER
builder.Register <IRead>(ctx => {
var input = ctx.ResolveNamed <InputContext>(entity.Key);
var rowFactory = ctx.ResolveNamed <IRowFactory>(entity.Key, new NamedParameter("capacity", input.RowCapacity));
switch (input.Connection.Provider)
{
case Constants.DefaultSetting:
case "internal":
return(new InternalReader(input, rowFactory));
default:
return(new NullReader(input, false));
}
}).Named <IRead>(entity.Key);
}
// Entity Output
if (_internal.Contains(_process.Output().Provider))
{
// PROCESS OUTPUT CONTROLLER
builder.Register <IOutputController>(ctx => new NullOutputController()).As <IOutputController>();
foreach (var entity in _process.Entities)
{
builder.Register <IOutputController>(ctx => new NullOutputController()).Named <IOutputController>(entity.Key);
builder.Register <IOutputProvider>(ctx => new InternalOutputProvider(ctx.ResolveNamed <OutputContext>(entity.Key), ctx.ResolveNamed <IWrite>(entity.Key))).Named <IOutputProvider>(entity.Key);
// WRITER
builder.Register <IWrite>(ctx => {
var output = ctx.ResolveNamed <OutputContext>(entity.Key);
switch (output.Connection.Provider)
{
case "trace":
return(new TraceWriter(new JsonNetSerializer(output)));
case Constants.DefaultSetting:
case "internal":
return(new InternalWriter(output));
case "text":
return(new FileStreamWriter(output, Console.OpenStandardOutput()));
case "log":
return(new NLogWriter(output));
default:
return(new NullWriter(output));
}
}).Named <IWrite>(entity.Key);
}
}
}
protected override void Load(ContainerBuilder builder)
{
if (_process == null)
{
return;
}
// connections
foreach (var connection in _process.Connections.Where(c => c.Provider.In(_ado)))
{
// Connection Factory
builder.Register <IConnectionFactory>(ctx => {
switch (connection.Provider)
{
case "sqlserver":
return(new SqlServerConnectionFactory(connection));
case "mysql":
return(new MySqlConnectionFactory(connection));
case "postgresql":
return(new PostgreSqlConnectionFactory(connection));
case "sqlite":
return(new SqLiteConnectionFactory(connection));
default:
return(new NullConnectionFactory());
}
}).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);
}
//ISchemaReader
//IOutputController
//IRead (Process for Calculated Columns)
//IWrite (Process for Calculated Columns)
//IInitializer (Process)
// Per Entity
// IInputVersionDetector
// IRead (Input, per Entity)
// IOutputController
// -- ITakeAndReturnRows (for matching)
// -- IWriteMasterUpdateQuery (for updating)
// IUpdate
// IWrite
// IEntityDeleteHandler
// entitiy input
foreach (var entity in _process.Entities.Where(e => _process.Connections.First(c => c.Name == e.Connection).Provider.In(_ado)))
{
// 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));
switch (input.Connection.Provider)
{
case "mysql":
case "postgresql":
case "sqlite":
case "sqlserver":
return(new AdoInputReader(
input,
input.InputFields,
ctx.ResolveNamed <IConnectionFactory>(input.Connection.Key),
rowFactory
));
default:
return(new NullReader(input, false));
}
}).Named <IRead>(entity.Key);
// INPUT VERSION DETECTOR
builder.Register <IInputVersionDetector>(ctx => {
var input = ctx.ResolveNamed <InputContext>(entity.Key);
switch (input.Connection.Provider)
{
case "mysql":
case "postgresql":
case "sqlite":
case "sqlserver":
return(new AdoInputVersionDetector(input, ctx.ResolveNamed <IConnectionFactory>(input.Connection.Key)));
default:
return(new NullVersionDetector());
}
}).Named <IInputVersionDetector>(entity.Key);
}
// entity output
if (_process.Output().Provider.In(_ado))
{
var calc = _process.ToCalculatedFieldsProcess();
// PROCESS OUTPUT CONTROLLER
builder.Register <IOutputController>(ctx => {
var output = ctx.Resolve <OutputContext>();
if (_process.Mode != "init")
{
return(new NullOutputController());
}
switch (output.Connection.Provider)
{
case "mysql":
case "postgresql":
case "sqlite":
case "sqlserver":
return(new AdoStarController(output, new AdoStarViewCreator(output, ctx.ResolveNamed <IConnectionFactory>(output.Connection.Key))));
default:
return(new NullOutputController());
}
}).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, new Incrementer(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, new Incrementer(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)
{
// ENTITY OUTPUT CONTROLLER
builder.Register <IOutputController>(ctx => {
var output = ctx.ResolveNamed <OutputContext>(entity.Key);
switch (output.Connection.Provider)
{
case "mysql":
case "postgresql":
case "sqlite":
case "sqlserver":
var initializer = _process.Mode == "init" ? (IAction) new AdoEntityInitializer(output, ctx.ResolveNamed <IConnectionFactory>(output.Connection.Key)) : new NullInitializer();
return(new AdoOutputController(
output,
initializer,
ctx.ResolveNamed <IInputVersionDetector>(entity.Key),
new AdoOutputVersionDetector(output, ctx.ResolveNamed <IConnectionFactory>(output.Connection.Key)),
ctx.ResolveNamed <IConnectionFactory>(output.Connection.Key)
));
default:
return(new NullOutputController());
}
}).Named <IOutputController>(entity.Key);
// OUTPUT ROW MATCHER
builder.Register(ctx => {
var output = ctx.ResolveNamed <OutputContext>(entity.Key);
var rowFactory = ctx.ResolveNamed <IRowFactory>(entity.Key, new NamedParameter("capacity", output.GetAllEntityFields().Count()));
var cf = ctx.ResolveNamed <IConnectionFactory>(output.Connection.Key);
switch (output.Connection.Provider)
{
case "sqlite":
return(new TypedEntityMatchingKeysReader(new AdoEntityMatchingKeysReader(output, cf, rowFactory), output));
default:
return((ITakeAndReturnRows) new AdoEntityMatchingKeysReader(output, cf, rowFactory));
}
}).Named <ITakeAndReturnRows>(entity.Key);
// MASTER UPDATE QUERY
builder.Register <IWriteMasterUpdateQuery>(ctx => {
var output = ctx.ResolveNamed <OutputContext>(entity.Key);
var factory = ctx.ResolveNamed <IConnectionFactory>(output.Connection.Key);
switch (output.Connection.Provider)
{
case "mysql":
return(new MySqlUpdateMasterKeysQueryWriter(output, factory));
case "postgresql":
return(new PostgreSqlUpdateMasterKeysQueryWriter(output, factory));
default:
return(new SqlServerUpdateMasterKeysQueryWriter(output, factory));
}
}).Named <IWriteMasterUpdateQuery>(entity.Key + "MasterKeys");
// UPDATER
builder.Register <IUpdate>(ctx => {
var output = ctx.ResolveNamed <OutputContext>(entity.Key);
switch (output.Connection.Provider)
{
case "mysql":
case "postgresql":
case "sqlserver":
return(new AdoMasterUpdater(
output,
ctx.ResolveNamed <IConnectionFactory>(output.Connection.Key),
ctx.ResolveNamed <IWriteMasterUpdateQuery>(entity.Key + "MasterKeys")
));
case "sqlite":
return(new AdoTwoPartMasterUpdater(output, ctx.ResolveNamed <IConnectionFactory>(output.Connection.Key)));
default:
return(new NullMasterUpdater());
}
}).Named <IUpdate>(entity.Key);
// WRITER
builder.Register <IWrite>(ctx => {
var output = ctx.ResolveNamed <OutputContext>(entity.Key);
switch (output.Connection.Provider)
{
case "sqlserver":
return(new SqlServerWriter(
output,
ctx.ResolveNamed <IConnectionFactory>(output.Connection.Key),
ctx.ResolveNamed <ITakeAndReturnRows>(entity.Key),
new AdoEntityUpdater(output, ctx.ResolveNamed <IConnectionFactory>(output.Connection.Key))
));
case "mysql":
case "postgresql":
case "sqlite":
var cf = ctx.ResolveNamed <IConnectionFactory>(output.Connection.Key);
return(new AdoEntityWriter(
output,
ctx.ResolveNamed <ITakeAndReturnRows>(entity.Key),
new AdoEntityInserter(output, cf),
new AdoEntityUpdater(output, cf)
));
default:
return(new NullWriter(output));
}
}).Named <IWrite>(entity.Key);
// DELETE HANDLER
if (entity.Delete)
{
builder.Register <IEntityDeleteHandler>(ctx => {
var context = ctx.ResolveNamed <IContext>(entity.Key);
var inputContext = ctx.ResolveNamed <InputContext>(entity.Key);
var rowCapacity = inputContext.Entity.GetPrimaryKey().Count();
var rowFactory = new RowFactory(rowCapacity, false, true);
IRead input = new NullReader(context);
var primaryKey = entity.GetPrimaryKey();
switch (inputContext.Connection.Provider)
{
case "mysql":
case "postgresql":
case "sqlite":
case "sqlserver":
input = new AdoReader(
inputContext,
primaryKey,
ctx.ResolveNamed <IConnectionFactory>(inputContext.Connection.Key),
rowFactory,
ReadFrom.Input
);
break;
}
IRead output = new NullReader(context);
IDelete deleter = new NullDeleter(context);
var outputConnection = _process.Output();
var outputContext = ctx.ResolveNamed <OutputContext>(entity.Key);
switch (outputConnection.Provider)
{
case "mysql":
case "postgresql":
case "sqlite":
case "sqlserver":
var ocf = ctx.ResolveNamed <IConnectionFactory>(outputConnection.Key);
output = new AdoReader(context, entity.GetPrimaryKey(), ocf, rowFactory, ReadFrom.Output);
deleter = new AdoDeleter(outputContext, ocf);
break;
}
var handler = new DefaultDeleteHandler(context, input, output, deleter);
// 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, _process, entity, primaryKey));
handler.Register(new StringTruncateTransfom(context, primaryKey));
return(new ParallelDeleteHandler(handler));
}).Named <IEntityDeleteHandler>(entity.Key);
}
}
}
}
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 == Access))
{
// Connection Factory
builder.Register <IConnectionFactory>(ctx => {
switch (connection.Provider)
{
case "access":
return(new AccessConnectionFactory(connection));
default:
return(new NullConnectionFactory());
}
}).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);
}
// entity input
foreach (var entity in process.Entities.Where(e => process.Connections.First(c => c.Name == e.Input).Provider == Access))
{
// 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));
switch (input.Connection.Provider)
{
case "access":
return(new AdoInputReader(
input,
input.InputFields,
ctx.ResolveNamed <IConnectionFactory>(input.Connection.Key),
rowFactory
));
default:
return(new NullReader(input, false));
}
}).Named <IRead>(entity.Key);
// INPUT VERSION DETECTOR
builder.Register <IInputProvider>(ctx => {
var input = ctx.ResolveNamed <InputContext>(entity.Key);
switch (input.Connection.Provider)
{
case "access":
return(new AdoInputProvider(input, ctx.ResolveNamed <IConnectionFactory>(input.Connection.Key)));
default:
return(new NullInputProvider());
}
}).Named <IInputProvider>(entity.Key);
}
// entity output
if (process.GetOutputConnection().Provider == Access)
{
var calc = process.ToCalculatedFieldsProcess();
// PROCESS OUTPUT CONTROLLER
builder.Register <IOutputController>(ctx => {
var output = ctx.Resolve <OutputContext>();
if (process.Mode != "init")
{
return(new NullOutputController());
}
switch (output.Connection.Provider)
{
case "access":
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));
default:
return(new NullOutputController());
}
}).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>();
var adoInit = new AdoInitializer(output, ctx.ResolveNamed <IConnectionFactory>(output.Connection.Key));
switch (output.Connection.Provider)
{
case "access":
return(new AccessInitializer(adoInit, output));
default:
return(adoInit);
}
}).As <IInitializer>();
// ENTITIES
foreach (var entity in process.Entities)
{
builder.Register <IOutputProvider>(ctx => {
IWrite writer;
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();
switch (output.Connection.Provider)
{
case "access":
writer = new AdoEntityWriter(
output,
matcher,
new AdoEntityInserter(output, cf),
entity.Update ? (IWrite) new AdoEntityUpdater(output, cf) : new NullWriter(output)
);
break;
default:
writer = new NullWriter(output);
break;
}
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();
switch (output.Connection.Provider)
{
case "access":
return(new AdoOutputController(
output,
new AccessInitializer(initializer, output),
ctx.ResolveNamed <IInputProvider>(entity.Key),
ctx.ResolveNamed <IOutputProvider>(entity.Key),
ctx.ResolveNamed <IConnectionFactory>(output.Connection.Key)
));
default:
return(new NullOutputController());
}
}).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 AccessUpdateMasterKeysQueryWriter(output, factory));
}).Named <IWriteMasterUpdateQuery>(entity.Key + "MasterKeys");
// MASTER UPDATER
builder.Register <IUpdate>(ctx => {
var output = ctx.ResolveNamed <OutputContext>(entity.Key);
switch (output.Connection.Provider)
{
case "access":
return(new AdoMasterUpdater(
output,
ctx.ResolveNamed <IConnectionFactory>(output.Connection.Key),
ctx.ResolveNamed <IWriteMasterUpdateQuery>(entity.Key + "MasterKeys")
));
default:
return(new NullMasterUpdater());
}
}).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);
switch (inputContext.Connection.Provider)
{
case "access":
return(new AdoReader(
inputContext,
entity.GetPrimaryKey(),
ctx.ResolveNamed <IConnectionFactory>(inputContext.Connection.Key),
rowFactory,
ReadFrom.Input
));
default:
return(ctx.IsRegisteredWithName <IReadInputKeysAndHashCodes>(entity.Key) ? ctx.ResolveNamed <IReadInputKeysAndHashCodes>(entity.Key) : new NullReader(inputContext));
}
}).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();
switch (outputConnection.Provider)
{
case "access":
var ocf = ctx.ResolveNamed <IConnectionFactory>(outputConnection.Key);
return(new AdoReader(context, entity.GetPrimaryKey(), ocf, rowFactory, ReadFrom.Output));
default:
return(ctx.IsRegisteredWithName <IReadOutputKeysAndHashCodes>(entity.Key) ? ctx.ResolveNamed <IReadOutputKeysAndHashCodes>(entity.Key) : new NullReader(context));
}
})).Named <IReadOutputKeysAndHashCodes>(entity.Key);
builder.Register(ctx => {
var outputConnection = process.GetOutputConnection();
var outputContext = ctx.ResolveNamed <OutputContext>(entity.Key);
switch (outputConnection.Provider)
{
case "access":
var ocf = ctx.ResolveNamed <IConnectionFactory>(outputConnection.Key);
return(new AdoDeleter(outputContext, ocf));
default:
return(ctx.IsRegisteredWithName <IDelete>(entity.Key) ? ctx.ResolveNamed <IDelete>(entity.Key) : new NullDeleter(outputContext));
}
}).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);
}
}
}
}
protected override void Load(ContainerBuilder builder)
{
if (_process == null && !builder.Properties.ContainsKey("Process"))
{
return;
}
var p = _process ?? (Process)builder.Properties["Process"];
// connections
foreach (var connection in p.Connections.Where(c => c.Provider == "file"))
{
// Schema Reader
builder.Register <ISchemaReader>(ctx => {
var context = ctx.ResolveNamed <IConnectionContext>(connection.Key);
var cfg = new FileInspection(context, FileUtility.Find(connection.File), connection.Sample).Create();
var process = new Process(cfg);
foreach (var warning in process.Warnings())
{
context.Warn(warning);
}
if (process.Errors().Any())
{
foreach (var error in process.Errors())
{
context.Error(error);
}
return(new NullSchemaReader());
}
var input = new InputContext(new PipelineContext(ctx.Resolve <IPipelineLogger>(), process, process.Entities.First()));
var rowFactory = new RowFactory(input.RowCapacity, input.Entity.IsMaster, false);
var reader = new CsvHelperReader(input, rowFactory);
return(new FileSchemaReader(process, input, reader));
}).Named <ISchemaReader>(connection.Key);
}
// entity input
foreach (var entity in p.Entities.Where(e => p.Connections.First(c => c.Name == e.Input).Provider == "file"))
{
// input version detector
builder.RegisterType <NullInputProvider>().Named <IInputProvider>(entity.Key);
// input read
builder.Register <IRead>(ctx => {
var input = ctx.ResolveNamed <InputContext>(entity.Key);
var rowFactory = ctx.ResolveNamed <IRowFactory>(entity.Key, new NamedParameter("capacity", input.RowCapacity));
if (input.Connection.Delimiter == string.Empty && input.Entity.Fields.Count(f => f.Input) == 1)
{
return(new FileReader(input, rowFactory));
}
return(new CsvHelperReader(input, rowFactory));
}).Named <IRead>(entity.Key);
}
// Entity Output
if (p.GetOutputConnection().Provider == "file")
{
// PROCESS OUTPUT CONTROLLER
builder.Register <IOutputController>(ctx => new NullOutputController()).As <IOutputController>();
foreach (var entity in p.Entities)
{
// ENTITY OUTPUT CONTROLLER
builder.Register <IOutputController>(ctx => {
var output = ctx.ResolveNamed <OutputContext>(entity.Key);
var fileInfo = new FileInfo(Path.Combine(output.Connection.Folder, output.Connection.File ?? output.Entity.OutputTableName(output.Process.Name)));
var folder = Path.GetDirectoryName(fileInfo.FullName);
var init = p.Mode == "init" || (folder != null && !Directory.Exists(folder));
var initializer = init ? (IInitializer) new FileInitializer(output) : new NullInitializer();
return(new FileOutputController(output, initializer, new NullInputProvider(), new NullOutputProvider()));
}).Named <IOutputController>(entity.Key);
// ENTITY WRITER
builder.Register <IWrite>(ctx => {
var output = ctx.ResolveNamed <OutputContext>(entity.Key);
switch (output.Connection.Provider)
{
case "file":
if (output.Connection.Delimiter == string.Empty)
{
output.Error("A delimiter is required for a file output.");
return(new NullWriter(output, true));
}
else
{
if (output.Connection.Stream && _streamWriter != null)
{
if (output.Connection.Synchronous)
{
return(new CsvHelperStreamWriterSync(output, _streamWriter));
}
else
{
return(new CsvHelperStreamWriter(output, _streamWriter));
}
}
else
{
var fileInfo = new FileInfo(Path.Combine(output.Connection.Folder, output.Connection.File ?? output.Entity.OutputTableName(output.Process.Name)));
var streamWriter = new StreamWriter(System.IO.File.OpenWrite(fileInfo.FullName));
return(output.Connection.Synchronous ? (IWrite) new CsvHelperStreamWriterSync(output, streamWriter) : new CsvHelperStreamWriter(output, streamWriter));
}
}
default:
return(new NullWriter(output, true));
}
}).Named <IWrite>(entity.Key);
}
}
}
protected override void Load(ContainerBuilder builder)
{
if (_process == null)
{
return;
}
// Connections
foreach (var connection in _process.Connections.Where(c => c.Provider == "internal"))
{
builder.RegisterType <NullSchemaReader>().Named <ISchemaReader>(connection.Key);
}
// Entity input
foreach (var entity in _process.Entities.Where(e => _internal.Contains(_process.Connections.First(c => c.Name == e.Connection).Provider)))
{
builder.RegisterType <NullInputProvider>().Named <IInputProvider>(entity.Key);
// Internal keys reader for HOT (HandsOnTable) editor
if (entity.Delete)
{
builder.Register <IReadInputKeysAndHashCodes>(ctx => {
// note: i tried to just load keys but had a lot of troubles, this works (for now).
var inputContext = ctx.ResolveNamed <InputContext>(entity.Key);
var rowFactory = new RowFactory(inputContext.RowCapacity, entity.IsMaster, false);
return(new InternalKeysReader(new InternalReader(inputContext, rowFactory)));
}).Named <IReadInputKeysAndHashCodes>(entity.Key);
}
// READER
builder.Register <IRead>(ctx => {
var input = ctx.ResolveNamed <InputContext>(entity.Key);
var rowFactory = ctx.ResolveNamed <IRowFactory>(entity.Key, new NamedParameter("capacity", input.RowCapacity));
if (_process.Mode == "form")
{
// if key filter exists
if (entity.GetPrimaryKey().Any() && entity.GetPrimaryKey().All(f => entity.Filter.Any(i => i.Field == f.Alias || i.Field == f.Name)))
{
if (entity.GetPrimaryKey().All(pk => entity.Filter.First(i => i.Field == pk.Alias || i.Field == pk.Name).Value == (pk.Default == Constants.DefaultSetting ? Constants.StringDefaults()[pk.Type] : pk.Default)))
{
// this is a form insert, create a new default row and apply parameters
return(new ParameterRowReader(input, new DefaultRowReader(input, rowFactory)));
}
}
}
switch (input.Connection.Provider)
{
case Constants.DefaultSetting:
case "internal":
return(new InternalReader(input, rowFactory));
default:
return(new NullReader(input, false));
}
}).Named <IRead>(entity.Key);
}
// Entity Output
if (_internal.Contains(_process.Output().Provider))
{
// PROCESS OUTPUT CONTROLLER
builder.Register <IOutputController>(ctx => new NullOutputController()).As <IOutputController>();
foreach (var entity in _process.Entities)
{
var e = entity;
builder.Register <IOutputController>(ctx => new NullOutputController()).Named <IOutputController>(e.Key);
builder.Register <IOutputProvider>(ctx => new InternalOutputProvider(ctx.ResolveNamed <OutputContext>(e.Key), ctx.ResolveNamed <IWrite>(e.Key))).Named <IOutputProvider>(e.Key);
// WRITER
builder.Register <IWrite>(ctx => {
var output = ctx.ResolveNamed <OutputContext>(e.Key);
switch (output.Connection.Provider)
{
case Constants.DefaultSetting:
case "internal":
return(new InternalWriter(output));
case "text":
return(new FileStreamWriter(output, HttpContext.Current.Response.OutputStream));
case "trace":
case "log":
return(new OrchardLogWriter(output));
default:
return(new NullWriter(output));
}
}).Named <IWrite>(entity.Key);
}
}
}
public RootHierarchicalRowInfo() : base(itemType: typeof(TItem), rowFactory: RowFactory <TItem> .Create(false))
{
}
