public void TestThatIsManipulatingFieldReturnsFalseIfFieldNameIsNotUsedInPrimaryKey()
{
var fixture = new Fixture();
fixture.Customize <Type>(e => e.FromFactory(() => typeof(object)));
fixture.Customize <IInformationLogger>(e => e.FromFactory(() => MockRepository.GenerateMock <IInformationLogger>()));
fixture.Customize <IMap>(e => e.FromFactory(() => MockRepository.GenerateMock <IMap>()));
fixture.Customize <IField>(e => e.FromFactory(() =>
{
var fieldMock = MockRepository.GenerateMock <IField>();
fieldMock.Expect(m => m.NameSource)
.Return(fixture.CreateAnonymous <string>())
.Repeat.Any();
return(fieldMock);
}));
fixture.Customize <KeyValuePair <IField, IMap> >(e => e.FromFactory(() => new KeyValuePair <IField, IMap>(fixture.CreateAnonymous <IField>(), null)));
fixture.Customize <ITable>(e => e.FromFactory(() =>
{
var candidateKey = MockRepository.GenerateMock <ICandidateKey>();
candidateKey.Expect(m => m.Fields)
.Return(new ReadOnlyObservableCollection <KeyValuePair <IField, IMap> >(new ObservableCollection <KeyValuePair <IField, IMap> >(fixture.CreateMany <KeyValuePair <IField, IMap> >(5).ToList())))
.Repeat.Any();
var tableMock = MockRepository.GenerateMock <ITable>();
tableMock.Expect(m => m.NameTarget)
.Return(fixture.CreateAnonymous <string>())
.Repeat.Any();
tableMock.Expect(m => m.PrimaryKey)
.Return(candidateKey)
.Repeat.Any();
return(tableMock);
}));
var dataSourceMock = MockRepository.GenerateMock <IDataSource>();
dataSourceMock.Expect(m => m.Tables)
.Return(new ReadOnlyObservableCollection <ITable>(new ObservableCollection <ITable>(fixture.CreateMany <ITable>(5).ToList())))
.Repeat.Any();
// ReSharper disable ImplicitlyCapturedClosure
fixture.Customize <IDataSource>(e => e.FromFactory(() => dataSourceMock));
// ReSharper restore ImplicitlyCapturedClosure
var metadataRepositoryMock = MockRepository.GenerateMock <IMetadataRepository>();
metadataRepositoryMock.Expect(m => m.DataSourceGet())
.Return(fixture.CreateAnonymous <IDataSource>())
.Repeat.Any();
fixture.Customize <IMetadataRepository>(e => e.FromFactory(() => metadataRepositoryMock));
var primaryKeyAdder = new PrimaryKeyAdder(dataSourceMock.Tables.ElementAt(0).NameTarget, fixture.CreateMany <string>().ToList(), new Dictionary <string, object>(), fixture.CreateAnonymous <IMetadataRepository>(), fixture.CreateAnonymous <IInformationLogger>());
Assert.That(primaryKeyAdder, Is.Not.Null);
Assert.That(primaryKeyAdder.IsManipulatingField(fixture.CreateAnonymous <string>(), dataSourceMock.Tables.ElementAt(0)), Is.False);
}
public void TestThatConstructorInitializeWorker()
{
var fixture = new Fixture();
fixture.Customize <ITable>(e => e.FromFactory(() =>
{
var tableMock = MockRepository.GenerateMock <ITable>();
tableMock.Expect(m => m.NameTarget)
.Return(fixture.CreateAnonymous <string>())
.Repeat.Any();
return(tableMock);
}));
var dataSourceMock = MockRepository.GenerateMock <IDataSource>();
dataSourceMock.Expect(m => m.Tables)
.Return(new ReadOnlyObservableCollection <ITable>(new ObservableCollection <ITable>(fixture.CreateMany <ITable>(5).ToList())))
.Repeat.Any();
fixture.Customize <IDataSource>(e => e.FromFactory(() => dataSourceMock));
var setFieldValuesMock = new Dictionary <string, object>
{
{ fixture.CreateAnonymous <string>(), fixture.CreateAnonymous <object>() },
{ fixture.CreateAnonymous <string>(), fixture.CreateAnonymous <object>() },
{ fixture.CreateAnonymous <string>(), fixture.CreateAnonymous <object>() }
};
var metadataRepositoryMock = MockRepository.GenerateMock <IMetadataRepository>();
metadataRepositoryMock.Expect(m => m.DataSourceGet())
.Return(fixture.CreateAnonymous <IDataSource>())
.Repeat.Any();
fixture.Customize <IMetadataRepository>(e => e.FromFactory(() => metadataRepositoryMock));
var informationLoggerMock = MockRepository.GenerateMock <IInformationLogger>();
fixture.Customize <IInformationLogger>(e => e.FromFactory(() => informationLoggerMock));
var worker = new PrimaryKeyAdder(dataSourceMock.Tables.ElementAt(0).NameTarget, fixture.CreateMany <string>(5).ToList(), setFieldValuesMock, fixture.CreateAnonymous <IMetadataRepository>(), fixture.CreateAnonymous <IInformationLogger>());
Assert.That(worker, Is.Not.Null);
Assert.That(worker.ForeignKeyTable, Is.Not.Null);
Assert.That(worker.ForeignKeyTable, Is.EqualTo(dataSourceMock.Tables.ElementAt(0)));
Assert.That(worker.SetFieldValues, Is.Not.Null);
Assert.That(worker.SetFieldValues, Is.Not.Empty);
Assert.That(worker.SetFieldValues, Is.EqualTo(setFieldValuesMock));
Assert.That(worker.InformationLogger, Is.Not.Null);
Assert.That(worker.InformationLogger, Is.EqualTo(informationLoggerMock));
metadataRepositoryMock.AssertWasCalled(m => m.DataSourceGet());
}
public void TestThatManipulateAddsMissingPrimaryKeyValues()
{
var r = new Random(DateTime.Now.Millisecond);
var fixture = new Fixture();
fixture.Customize <Type>(e => e.FromFactory(() => typeof(object)));
fixture.Customize <IMap>(e => e.FromFactory(() => MockRepository.GenerateMock <IMap>()));
// ReSharper disable ImplicitlyCapturedClosure
fixture.Customize <IField>(e => e.FromFactory(() =>
{
var fieldMock = MockRepository.GenerateMock <IField>();
fieldMock.Expect(m => m.NameSource)
.Return(fixture.CreateAnonymous <string>())
.Repeat.Any();
fieldMock.Expect(m => m.DatatypeOfSource)
.Return(typeof(string))
.Repeat.Any();
fieldMock.Expect(m => m.DatatypeOfTarget)
.Return(typeof(string))
.Repeat.Any();
fieldMock.Expect(m => m.CreateDataObject(Arg <object> .Is.Anything))
.WhenCalled(f =>
{
var dataObjectMock = MockRepository.GenerateMock <IFieldData <string, string> >();
dataObjectMock.Expect(m => m.Field)
.Return(fieldMock)
.Repeat.Any();
f.ReturnValue = dataObjectMock;
})
.Return(null)
.Repeat.Any();
return(fieldMock);
}));
// ReSharper restore ImplicitlyCapturedClosure
// ReSharper disable ImplicitlyCapturedClosure
fixture.Customize <ITable>(e => e.FromFactory(() =>
{
var fieldCollection = fixture.CreateMany <IField>(r.Next(5, 10)).ToList();
var tableMock = MockRepository.GenerateMock <ITable>();
var candidateKeyMock = MockRepository.GenerateMock <ICandidateKey>();
candidateKeyMock.Expect(m => m.Table)
.Return(tableMock)
.Repeat.Any();
candidateKeyMock.Expect(m => m.Fields)
.Return(new ReadOnlyObservableCollection <KeyValuePair <IField, IMap> >(new ObservableCollection <KeyValuePair <IField, IMap> >(new List <KeyValuePair <IField, IMap> > {
new KeyValuePair <IField, IMap>(fieldCollection.ElementAt(0), null), new KeyValuePair <IField, IMap>(fieldCollection.ElementAt(1), null), new KeyValuePair <IField, IMap>(fieldCollection.ElementAt(2), null)
})))
.Repeat.Any();
tableMock.Expect(m => m.NameTarget)
.Return(fixture.CreateAnonymous <string>())
.Repeat.Any();
tableMock.Expect(m => m.Fields)
.Return(new ReadOnlyObservableCollection <IField>(new ObservableCollection <IField>(fieldCollection)))
.Repeat.Any();
tableMock.Expect(m => m.CandidateKeys)
.Return(new ReadOnlyObservableCollection <ICandidateKey>(new ObservableCollection <ICandidateKey>(new List <ICandidateKey> {
candidateKeyMock
})))
.Repeat.Any();
tableMock.Expect(m => m.PrimaryKey)
.Return(tableMock.CandidateKeys.ElementAt(0))
.Repeat.Any();
tableMock.Expect(m => m.RecordFilters)
.Return(new ReadOnlyObservableCollection <IFilter>(new ObservableCollection <IFilter>(new List <IFilter>(0))))
.Repeat.Any();
tableMock.Expect(m => m.CreateRow())
.WhenCalled(f => f.ReturnValue = tableMock.Fields.Select(m => m.CreateDataObject(null)).ToList())
.Return(null)
.Repeat.Any();
tableMock.Expect(m => m.Clone())
.Return(tableMock)
.Repeat.Any();
return(tableMock);
}));
// ReSharper restore ImplicitlyCapturedClosure
var dataSourceMock = MockRepository.GenerateMock <IDataSource>();
dataSourceMock.Expect(m => m.Tables)
.Return(new ReadOnlyObservableCollection <ITable>(new ObservableCollection <ITable>(fixture.CreateMany <ITable>(5).ToList())))
.Repeat.Any();
fixture.Customize <IDataSource>(e => e.FromFactory(() => dataSourceMock));
var metadataRepositoryMock = MockRepository.GenerateMock <IMetadataRepository>();
metadataRepositoryMock.Expect(m => m.DataSourceGet())
.Return(fixture.CreateAnonymous <IDataSource>())
.Repeat.Any();
fixture.Customize <IMetadataRepository>(e => e.FromFactory(() => metadataRepositoryMock));
var dataRepositoryMock = MockRepository.GenerateMock <IDataRepository>();
dataRepositoryMock.Expect(m => m.DataGetFromTable(Arg <ITable> .Is.NotNull))
.WhenCalled(e =>
{
var table = (ITable)e.Arguments[0];
var numberOfRows = r.Next(10, 250);
var dataForTable = new Collection <IEnumerable <IDataObjectBase> >();
while (dataForTable.Count < numberOfRows)
{
var dataForRow = new Collection <IDataObjectBase>();
for (var columnNo = 0; columnNo < table.Fields.Count; columnNo++)
{
var fieldDataMock = MockRepository.GenerateMock <IFieldData <string, string> >();
fieldDataMock.Expect(m => m.Field)
.Return(table.Fields.ElementAt(columnNo))
.Repeat.Any();
fieldDataMock.Expect(m => m.SourceValue)
.Return(fixture.CreateAnonymous <string>())
.Repeat.Any();
fieldDataMock.Expect(m => m.GetSourceValue <string>())
.Return(fieldDataMock.SourceValue)
.Repeat.Any();
fieldDataMock.Expect(m => m.GetTargetValue <string>())
.Return(fieldDataMock.SourceValue)
.Repeat.Any();
fieldDataMock.Expect(m => m.GetTargetValue <string>(Arg <IMap> .Is.Anything))
.Return(fieldDataMock.SourceValue)
.Repeat.Any();
dataForRow.Add(fieldDataMock);
}
dataForTable.Add(dataForRow);
}
var eventArgsMock = MockRepository.GenerateMock <IHandleDataEventArgs>();
eventArgsMock.Expect(m => m.Table)
.Return(table)
.Repeat.Any();
eventArgsMock.Expect(m => m.Data)
.Return(dataForTable)
.Repeat.Any();
dataRepositoryMock.Raise(n => n.OnHandleData += null, this, eventArgsMock);
})
.Repeat.Any();
dataRepositoryMock.Expect(m => m.Clone())
.Return(dataRepositoryMock)
.Repeat.Any();
// ReSharper disable ImplicitlyCapturedClosure
fixture.Customize <IDataRepository>(e => e.FromFactory(() => dataRepositoryMock));
// ReSharper restore ImplicitlyCapturedClosure
var informationLoggerMock = MockRepository.GenerateMock <IInformationLogger>();
fixture.Customize <IInformationLogger>(e => e.FromFactory(() => informationLoggerMock));
var primaryTable = dataSourceMock.Tables.ElementAt(0);
var secondaryTable = dataSourceMock.Tables.ElementAt(1);
var worker = new PrimaryKeyAdder(secondaryTable.NameTarget, new[] { secondaryTable.Fields.ElementAt(secondaryTable.Fields.Count - 3).NameSource, secondaryTable.Fields.ElementAt(secondaryTable.Fields.Count - 2).NameSource, secondaryTable.Fields.ElementAt(secondaryTable.Fields.Count - 1).NameSource }, new Dictionary <string, object> {
{ primaryTable.Fields.Last().NameSource, fixture.CreateAnonymous <string>() }
}, fixture.CreateAnonymous <IMetadataRepository>(), fixture.CreateAnonymous <IInformationLogger>());
Assert.That(worker, Is.Not.Null);
// ReSharper disable ImplicitlyCapturedClosure
dataRepositoryMock.OnHandleData += (s, e) =>
{
Assert.That(s, Is.Not.Null);
Assert.That(e, Is.Not.Null);
Assert.That(e.Table, Is.Not.Null);
Assert.That(e.Data, Is.Not.Null);
Assert.That(e.Data, Is.Not.Empty);
if (e.Table.Equals(primaryTable) == false)
{
return;
}
var primaryTableData = e.Data.ToList();
var numberOfRowsBefore = primaryTableData.Count;
var manipulatedData = worker.FinalizeDataManipulation(primaryTable, fixture.CreateAnonymous <IDataRepository>(), worker.ManipulateData(primaryTable, fixture.CreateAnonymous <IDataRepository>(), primaryTableData).ToList()).ToList();
Assert.That(manipulatedData, Is.Not.Null);
Assert.That(manipulatedData, Is.Not.Empty);
Assert.That(manipulatedData.Count, Is.GreaterThan(numberOfRowsBefore));
for (var manipulatedDataRowNo = numberOfRowsBefore; manipulatedDataRowNo < manipulatedData.Count; manipulatedDataRowNo++)
{
manipulatedData.ElementAt(manipulatedDataRowNo)
.ElementAt(0)
.AssertWasCalled(m => m.UpdateSourceValue(Arg <string> .Is.NotNull));
manipulatedData.ElementAt(manipulatedDataRowNo)
.ElementAt(1)
.AssertWasCalled(m => m.UpdateSourceValue(Arg <string> .Is.NotNull));
manipulatedData.ElementAt(manipulatedDataRowNo)
.ElementAt(2)
.AssertWasCalled(m => m.UpdateSourceValue(Arg <string> .Is.NotNull));
manipulatedData.ElementAt(manipulatedDataRowNo)
.Last()
.AssertWasCalled(m => m.UpdateSourceValue(Arg <string> .Is.NotNull));
}
};
// ReSharper restore ImplicitlyCapturedClosure
dataRepositoryMock.DataGetFromTable(primaryTable);
primaryTable.AssertWasCalled(m => m.PrimaryKey);
secondaryTable.AssertWasCalled(m => m.Clone());
secondaryTable.AssertWasCalled(m => m.RecordFilters);
dataRepositoryMock.AssertWasCalled(m => m.Clone());
dataRepositoryMock.AssertWasCalled(m => m.DataGetFromTable(Arg <ITable> .Is.Equal(secondaryTable)));
primaryTable.AssertWasCalled(m => m.CreateRow());
informationLoggerMock.AssertWasCalled(m => m.LogInformation(Arg <string> .Is.NotNull));
}
/// <summary>
/// Adding configuration to the container for Inversion of Control.
/// </summary>
/// <param name="container">Container for Inversion of Control.</param>
public void AddConfiguration(IWindsorContainer container)
{
var dataManipulatorsFileName = ConfigurationManager.AppSettings["DataManipulatorsFileName"];
if (dataManipulatorsFileName == null)
{
throw new DeliveryEngineSystemException(Resource.GetExceptionMessage(ExceptionMessage.ApplicationSettingMissing, "DataManipulatorsFileName"));
}
dataManipulatorsFileName = Environment.ExpandEnvironmentVariables(dataManipulatorsFileName);
if (string.IsNullOrEmpty(dataManipulatorsFileName))
{
container.Register(Component.For <IDataManipulators>().ImplementedBy <DataManipulators>().LifeStyle.Transient);
return;
}
if (!File.Exists(dataManipulatorsFileName))
{
throw new DeliveryEngineSystemException(Resource.GetExceptionMessage(ExceptionMessage.FileNotFound, dataManipulatorsFileName));
}
var assembly = typeof(DataManipulators).Assembly;
using (var resourceStream = assembly.GetManifestResourceStream(string.Format("{0}.Schemas.DataManipulators.xsd", assembly.GetName().Name)))
{
if (resourceStream == null)
{
throw new DeliveryEngineSystemException(Resource.GetExceptionMessage(ExceptionMessage.ResourceNotFound, string.Format("{0}.Schemas.DataManipulators.xsd", assembly.GetName().Name)));
}
var schema = XmlSchema.Read(resourceStream, ValidationEventHandler);
var readerSettings = new XmlReaderSettings
{
IgnoreComments = true,
IgnoreProcessingInstructions = true,
IgnoreWhitespace = true,
ValidationFlags = XmlSchemaValidationFlags.ReportValidationWarnings,
ValidationType = ValidationType.Schema
};
readerSettings.Schemas.Add(schema);
readerSettings.ValidationEventHandler += ValidationEventHandler;
var reader = XmlReader.Create(dataManipulatorsFileName, readerSettings);
try
{
var document = new XmlDocument();
document.Load(reader);
var namespaceManager = new XmlNamespaceManager(document.NameTable);
namespaceManager.AddNamespace("ns", schema.TargetNamespace);
var dataSetterNodeList = document.SelectNodes("/ns:DataManipulators/ns:DataSetter", namespaceManager);
if (dataSetterNodeList != null && dataSetterNodeList.Count > 0)
{
var dataSetterNo = 0;
foreach (XmlNode dataSetterNode in dataSetterNodeList)
{
var criteriaConfigurations = GenerateCriteriaConfigurations(dataSetterNode.SelectNodes("ns:EqualCriteria | ns:PoolCriteria | ns:IntervalCriteria", namespaceManager));
// ReSharper disable PossibleNullReferenceException
var dataSetter = new DataSetter(dataSetterNode.Attributes["table"].Value, dataSetterNode.SelectSingleNode("ns:Field", namespaceManager).Attributes["name"].Value, dataSetterNode.SelectSingleNode("ns:Field", namespaceManager).Attributes["value"].Value, criteriaConfigurations);
// ReSharper restore PossibleNullReferenceException
container.Register(Component.For <IDataSetter>().Named(string.Format("{0}[{1}]", typeof(IDataSetter).Name, dataSetterNo++)).Instance(dataSetter).LifeStyle.Transient);
}
}
var regularExpressionReplacerNodeList = document.SelectNodes("/ns:DataManipulators/ns:RegularExpressionReplacer", namespaceManager);
if (regularExpressionReplacerNodeList != null && regularExpressionReplacerNodeList.Count > 0)
{
var regularExpressionReplacerNo = 0;
foreach (XmlNode regularExpressionReplacerNode in regularExpressionReplacerNodeList)
{
var fieldNode = regularExpressionReplacerNode.SelectSingleNode("ns:Field", namespaceManager);
// ReSharper disable PossibleNullReferenceException
var regularExpression = new Regex(fieldNode.Attributes["regularExpression"].Value, RegexOptions.Compiled);
var newFieldValue = fieldNode.Attributes["value"].Value;
var regularExpressionReplacer = new RegularExpressionReplacer(regularExpressionReplacerNode.Attributes["table"].Value, regularExpression, (RegularExpressionApplyOn)Enum.Parse(typeof(RegularExpressionApplyOn), fieldNode.Attributes["applyOn"].Value), fieldNode.Attributes["name"].Value, Equals(newFieldValue, "{null}") ? null : newFieldValue);
// ReSharper restore PossibleNullReferenceException
container.Register(Component.For <IRegularExpressionReplacer>().Named(string.Format("{0}[{1}]", typeof(IRegularExpressionReplacer).Name, regularExpressionReplacerNo++)).Instance(regularExpressionReplacer).LifeStyle.Transient);
}
}
var rowDuplicatorNodeList = document.SelectNodes("/ns:DataManipulators/ns:RowDuplicator", namespaceManager);
if (rowDuplicatorNodeList != null && rowDuplicatorNodeList.Count > 0)
{
var rowDuplicatorNo = 0;
foreach (XmlNode rowDuplicatorNode in rowDuplicatorNodeList)
{
var criteriaConfigurations = GenerateCriteriaConfigurations(rowDuplicatorNode.SelectNodes("ns:EqualCriteria | ns:PoolCriteria | ns:IntervalCriteria", namespaceManager));
var fieldUpdates = new Collection <Tuple <string, object> >();
var fieldNodeList = rowDuplicatorNode.SelectNodes("ns:Field", namespaceManager);
if (fieldNodeList != null && fieldNodeList.Count > 0)
{
foreach (XmlNode fieldNode in fieldNodeList)
{
// ReSharper disable PossibleNullReferenceException
fieldUpdates.Add(new Tuple <string, object>(fieldNode.Attributes["name"].Value, fieldNode.Attributes["value"].Value));
// ReSharper restore PossibleNullReferenceException
}
}
// ReSharper disable PossibleNullReferenceException
var rowDuplicator = new RowDuplicator(rowDuplicatorNode.Attributes["table"].Value, fieldUpdates, criteriaConfigurations);
// ReSharper restore PossibleNullReferenceException
container.Register(Component.For <IRowDuplicator>().Named(string.Format("{0}[{1}]", typeof(IRowDuplicator).Name, rowDuplicatorNo++)).Instance(rowDuplicator).LifeStyle.Transient);
}
}
var missingForeignKeyHandlerNodeList = document.SelectNodes("ns:DataManipulators/ns:MissingForeignKeyHandler", namespaceManager);
if (missingForeignKeyHandlerNodeList != null && missingForeignKeyHandlerNodeList.Count > 0)
{
var missingForeignKeyHandlerNo = 0;
foreach (XmlNode missingForeignKeyHandlerNode in missingForeignKeyHandlerNodeList)
{
var workerNode = missingForeignKeyHandlerNode.SelectSingleNode("ns:PrimaryKeyAdder | ns:ForeignKeyCleaner | ns:ForeignKeyDeleter", namespaceManager);
if (workerNode == null)
{
continue;
}
var foreignKeyFields = new List <string>();
var foreignKeyFieldNodeList = workerNode.SelectNodes("ns:ForeignKey", namespaceManager);
if (foreignKeyFieldNodeList != null && foreignKeyFieldNodeList.Count > 0)
{
// ReSharper disable PossibleNullReferenceException
foreignKeyFields.AddRange(from XmlNode foreignKeyFieldNode in foreignKeyFieldNodeList select foreignKeyFieldNode.Attributes["field"].Value);
// ReSharper restore PossibleNullReferenceException
}
IMissingForeignKeyWorker worker = null;
switch (workerNode.LocalName)
{
case "PrimaryKeyAdder":
var setFieldValues = new Dictionary <string, object>();
var setFieldValueNodeList = workerNode.SelectNodes("ns:SetValue", namespaceManager);
if (setFieldValueNodeList != null && setFieldValueNodeList.Count > 0)
{
foreach (XmlNode setFieldValueNode in setFieldValueNodeList)
{
// ReSharper disable PossibleNullReferenceException
setFieldValues.Add(setFieldValueNode.Attributes["field"].Value, setFieldValueNode.Attributes["value"].Value);
// ReSharper restore PossibleNullReferenceException
}
}
try
{
// ReSharper disable PossibleNullReferenceException
worker = new PrimaryKeyAdder(workerNode.Attributes["targetTable"].Value, foreignKeyFields, setFieldValues, container.Resolve <IMetadataRepository>(), container.Resolve <IInformationLogger>());
// ReSharper restore PossibleNullReferenceException
}
catch (DeliveryEngineSystemException)
{
continue;
}
break;
case "ForeignKeyCleaner":
try
{
// ReSharper disable PossibleNullReferenceException
worker = new ForeignKeyCleaner(workerNode.Attributes["targetTable"].Value, foreignKeyFields, container.Resolve <IMetadataRepository>(), container.Resolve <IInformationLogger>());
// ReSharper restore PossibleNullReferenceException
}
catch (DeliveryEngineSystemException)
{
continue;
}
break;
case "ForeignKeyDeleter":
try
{
// ReSharper disable PossibleNullReferenceException
worker = new ForeignKeyDeleter(workerNode.Attributes["targetTable"].Value, foreignKeyFields, container.Resolve <IMetadataRepository>(), container.Resolve <IInformationLogger>());
// ReSharper restore PossibleNullReferenceException
}
catch (DeliveryEngineSystemException)
{
continue;
}
break;
}
// ReSharper disable PossibleNullReferenceException
var missingForeignKeHandler = new MissingForeignKeyHandler(missingForeignKeyHandlerNode.Attributes["table"].Value, worker, container.Resolve <IContainer>());
// ReSharper restore PossibleNullReferenceException
container.Register(Component.For <IMissingForeignKeyHandler>().Named(string.Format("{0}[{1}]", typeof(IMissingForeignKeyHandler).Name, missingForeignKeyHandlerNo++)).Instance(missingForeignKeHandler).LifeStyle.Transient);
}
}
}
finally
{
reader.Close();
}
resourceStream.Close();
}
container.Register(Component.For <IDataManipulators>().ImplementedBy <DataManipulators>().LifeStyle.Transient);
}
