public void SatisfyImports_Recomposable_Unregister_ValueShouldChangeOnce()
{
var exportProvider = ExportProviderFactory.CreateRecomposable();
var engine = new ImportEngine(exportProvider);
exportProvider.AddExport("Value", 21);
var import = ImportDefinitionFactory.Create("Value", true);
var importer = PartFactory.CreateImporter(import);
engine.SatisfyImports(importer);
Assert.Equal(21, importer.GetImport(import));
exportProvider.ReplaceExportValue("Value", 42);
Assert.Equal(42, importer.GetImport(import));
engine.ReleaseImports(importer, null);
exportProvider.ReplaceExportValue("Value", 666);
Assert.Equal(42, importer.GetImport(import));
GC.KeepAlive(importer);
}
public void SatisfyImports_OneRecomposable_OneNotRecomposable()
{
var exportProvider = ExportProviderFactory.CreateRecomposable();
var engine = new ImportEngine(exportProvider);
var import1 = ImportDefinitionFactory.Create("Value", true);
var import2 = ImportDefinitionFactory.Create("Value", false);
var importer = PartFactory.CreateImporter(import1, import2);
exportProvider.AddExport("Value", 21);
engine.SatisfyImports(importer);
// Initial compose values should be 21
Assert.Equal(21, importer.GetImport(import1));
Assert.Equal(21, importer.GetImport(import2));
// Reset value to ensure it doesn't get set to same value again
importer.ResetImport(import1);
importer.ResetImport(import2);
Assert.Throws <ChangeRejectedException>(() =>
exportProvider.ReplaceExportValue("Value", 42));
Assert.Equal(null, importer.GetImport(import1));
Assert.Equal(null, importer.GetImport(import2));
GC.KeepAlive(importer);
}
public void TestImports()
{
File.Delete(newDataRoot + "cmd_out.txt"); //this is needed because the add on the ds/_start has no value and gets ignored
ImportEngine eng = new ImportEngine();
eng.Load(root + "import.xml");
var report = eng.Import("json,jsoncmd,tika_raw,tika_sort_title,tika_undup_title");
Console.WriteLine(report);
Assert.AreEqual(null, report.ErrorMessage);
CheckFiles("cmd_out.txt");
CheckFiles("json_out.txt");
CheckFiles("tika_raw.txt");
CheckFiles("tika_sort_title.txt");
CheckFiles("tika_undup_title.txt");
Assert.AreEqual(5, report.DatasourceReports.Count);
int i = -1;
checkDataSourceStats(report.DatasourceReports[++i], 5, 5);//The string value will not be added, bcause its emitted as 'record'. It is 5/5 because there are 2 EP's. Maybe we need to do something for the string value...
checkDataSourceStats(report.DatasourceReports[++i], 5, 5);
checkDataSourceStats(report.DatasourceReports[++i], 10, 10);
checkDataSourceStats(report.DatasourceReports[++i], 10, 10);
checkDataSourceStats(report.DatasourceReports[++i], 10, 3);
}
private void tsbImportNN_Click(object sender, EventArgs e)
{
listLog.Items.Clear();
var settings = new ImportFileSettings
{
FirstEntity = ((EntityInfo)cbbFirstEntity.SelectedItem).Metadata.LogicalName,
FirstAttributeIsGuid = rdbFirstGuid.Checked,
FirstAttributeName = ((AttributeInfo)cbbFirstEntityAttribute.SelectedItem).Metadata.LogicalName,
Relationship = ((RelationshipInfo)cbbRelationship.SelectedItem).Metadata.SchemaName,
SecondEntity = ((EntityInfo)cbbSecondEntity.SelectedItem).Metadata.LogicalName,
SecondAttributeIsGuid = rdbSecondGuid.Checked,
SecondAttributeName = ((AttributeInfo)cbbSecondEntityAttribute.SelectedItem).Metadata.LogicalName,
};
WorkAsync("Importing many to many relationships...",
evt =>
{
var innerSettings = (ImportFileSettings)((object[])evt.Argument)[0];
var filePath = ((object[])evt.Argument)[1].ToString();
var ie = new ImportEngine(filePath, this.Service, innerSettings);
ie.RaiseError += ie_RaiseError;
ie.RaiseSuccess += ie_RaiseSuccess;
ie.Import();
},
evt => {},
new object[] { settings, txtFilePath.Text });
}
public ShellStreamProvider(PipelineContext ctx, XmlNode node, XmlNode parentNode, StreamDirectory parent)
: base(parent, node)
{
engine = ctx.ImportEngine;
if (parentNode == null)
{
parentNode = node;
}
silent = (ctx.ImportFlags & _ImportFlags.Silent) != 0;
uri = new Uri("cmd://something");
resultTypes = new ProcessResultTypes();
resultTypes.Add(0, 0);
resultTypes.Add(node.ReadStr("@ignore_errors", null), 1);
resultTypes.Add(node.ReadStr("@ok_errors", null), 0);
buffered = node.ReadBool("@buffered", true);
stderrToStdout = node.ReadBool("@stderr_to_stdout", false);
Command = node.ReadStr("@cmd");
Arguments = node.ReadStr("@args", null);
ViaShell = node.ReadBool("@viashell", false);
if (ViaShell && Arguments != null)
{
throw new BMNodeException(node, "Attributes @args cannot be specified when @viashell=true.");
}
}
private StreamDirectory createFromNode(PipelineContext ctx, XmlElement providerNode, XmlElement parentNode, bool mustExcept)
{
String type = providerNode.ReadStr("@type", null);
if (type != null && providerNode.LocalName == "provider") //Node could be a datasource, where type describes the type of the datasource
{
return(ImportEngine.CreateObject <StreamDirectory>(type, ctx, providerNode, parentNode));
}
if (providerNode.GetAttributeNode("file") != null || providerNode.GetAttributeNode("root") != null)
{
return(new FileStreamDirectory(ctx, providerNode, parentNode));
}
if (providerNode.GetAttributeNode("url") != null)
{
return(new WebStreamDirectory(ctx, providerNode, parentNode));
}
if (providerNode.GetAttributeNode("cmd") != null)
{
return(new ShellStreamDirectory(ctx, providerNode, parentNode));
}
if (mustExcept)
{
XmlUtils.ThrowMissingException(providerNode, "@type, @file, @root or @url");
}
return(null);
}
public void TestCategories()
{
using (ImportEngine eng = new ImportEngine())
{
XmlHelper xml = new XmlHelper();
xml.LoadXml("<category/>");
xml.WriteVal("@name", "boo");
xml.WriteVal("@cat", "self");
xml.WriteVal("@dstfield", "cat");
var sel = xml.DocumentElement.AddElement("select");
sel.SetAttribute("field", "name");
sel.SetAttribute("expr", "weerd");
Category cat = Category.Create(xml.DocumentElement);
PipelineContext ctx = new PipelineContext(eng);
EndpointWrapper ep = new EndpointWrapper(eng, xml.DocumentElement);
IDataEndpoint dep = ep.CreateDataEndpoint(ctx, "abc");
dep.SetField("name", "peter weerd");
bool handled = cat.HandleRecord(ctx, dep, (JObject)dep.GetField(null));
Assert.IsTrue(handled);
Assert.AreEqual("self", dep.GetFieldAsStr("cat"));
dep.SetField("name", "peter weerd peter");
handled = cat.HandleRecord(ctx, dep, (JObject)dep.GetField(null));
Assert.IsTrue(handled);
Assert.AreEqual("self;self", dep.GetFieldAsStr("cat"));
}
}
private void comboBox1_SelectedIndexChanged(object sender, EventArgs e)
{
importLog.Log("selindexchanged");
dsList.Items.Clear();
using (ImportEngine engine = new ImportEngine())
{
engine.Load(comboBox1.Text);
cbEndpoints.Items.Clear();
cbEndpoints.Items.Add(String.Empty);
foreach (var item in engine.Endpoints)
{
cbEndpoints.Items.Add(item.Name);
}
cbPipeLines.Items.Clear();
cbPipeLines.Items.Add(String.Empty);
foreach (var item in engine.Pipelines)
{
cbPipeLines.Items.Add(item.Name);
}
uiFromFlags(engine);
txtMaxRecords.Text = engine.MaxAdds.ToString();
txtMaxEmits.Text = engine.MaxEmits.ToString();
foreach (var ds in engine.Datasources)
{
dsList.Items.Add(ds.Name, ds.Active);
}
}
}
public void PreviewImports_ReleaseImports_ShouldNotBlockChanges()
{
var exportProvider = ExportProviderFactory.CreateRecomposable();
var engine = new ImportEngine(exportProvider);
var import = ImportDefinitionFactory.Create("Value");
var importer = PartFactory.CreateImporter(import);
exportProvider.AddExport("Value", 21);
engine.PreviewImports(importer, null);
Assert.Throws <ChangeRejectedException>(() =>
exportProvider.AddExport("Value", 22));
Assert.Throws <ChangeRejectedException>(() =>
exportProvider.RemoveExport("Value"));
engine.ReleaseImports(importer, null);
exportProvider.AddExport("Value", 22);
exportProvider.RemoveExport("Value");
GC.KeepAlive(importer);
}
public void SatisfyImports_TwoRecomposables_SingleExportValueChanged()
{
var exportProvider = ExportProviderFactory.CreateRecomposable();
var engine = new ImportEngine(exportProvider);
var import1 = ImportDefinitionFactory.Create("Value1", true);
var import2 = ImportDefinitionFactory.Create("Value2", true);
var importer = PartFactory.CreateImporter(import1, import2);
exportProvider.AddExport("Value1", 21);
exportProvider.AddExport("Value2", 23);
engine.SatisfyImports(importer);
Assert.Equal(21, importer.GetImport(import1));
Assert.Equal(23, importer.GetImport(import2));
importer.ResetImport(import1);
importer.ResetImport(import2);
// Only change Value1
exportProvider.ReplaceExportValue("Value1", 42);
Assert.Equal(42, importer.GetImport(import1));
Assert.Equal(null, importer.GetImport(import2));
GC.KeepAlive(importer);
}
public override void Update()
{
if (Session.FindObject <PersistentAssemblyInfo>(info => info.Name == MasterDetailDynamicAssembly) == null)
{
var importEngine = new ImportEngine();
importEngine.ImportObjects(new UnitOfWork(Session.DataLayer), GetType(), "DynamicAssemblyMasterDetail.xml");
}
}
public void CreateImportEngineInstance()
{
string[] args = new string[] { "-i=/path/to/folder", "-o=/dev/opt/path" };
Arguments arguments = new Arguments(args);
engine = new ImportEngine(arguments);
}
public override void Update()
{
if (Session.FindObject <PersistentAssemblyInfo>(info => info.Name == MasterDetailDynamicAssembly) == null)
{
var importEngine = new ImportEngine();
importEngine.ImportObjects(new XPObjectSpace(XafTypesInfo.Instance, XpandModuleBase.XpoTypeInfoSource, () => new UnitOfWork(Session.DataLayer)), GetType(), "DynamicAssemblyMasterDetail.xml");
}
}
public override void UpdateDatabaseAfterUpdateSchema()
{
base.UpdateDatabaseAfterUpdateSchema();
if (ObjectSpace.QueryObject <PersistentAssemblyInfo>(info => info.Name == MasterDetailDynamicAssembly) == null)
{
var importEngine = new ImportEngine();
importEngine.ImportObjects(info => ObjectSpace, GetType(), "DynamicAssemblyMasterDetail.xml");
}
}
void importWorker_DoWork(object sender, DoWorkEventArgs e)
{
var settings = (ImportFileSettings)((object[])e.Argument)[0];
var filePath = ((object[])e.Argument)[1].ToString();
var ie = new ImportEngine(filePath, service, settings);
ie.RaiseError += ie_RaiseError;
ie.RaiseSuccess += ie_RaiseSuccess;
ie.Import();
}
void Import()
{
if (ObjectSpace.QueryObject <Analysis>(analysis => analysis.Name == "Controlling Grid Settings") == null)
{
var importEngine = new ImportEngine();
Stream stream = GetType().Assembly.GetManifestResourceStream(GetType(), "AnalysisObjects.xml");
importEngine.ImportObjects(stream, info => ObjectSpace);
stream = GetType().Assembly.GetManifestResourceStream(GetType(), "AnalysisObjectsConfiguration.xml");
importEngine.ImportObjects(stream, info => ObjectSpace);
}
}
public void PreviewImports_ZeroCollectionImport_ShouldSucceed()
{
var exportProvider = ExportProviderFactory.CreateRecomposable();
var engine = new ImportEngine(exportProvider);
var import = ImportDefinitionFactory.Create("Value", ImportCardinality.ZeroOrMore);
var importer = PartFactory.CreateImporter(import);
engine.PreviewImports(importer, null);
GC.KeepAlive(importer);
}
public override void UpdateDatabaseAfterUpdateSchema()
{
base.UpdateDatabaseAfterUpdateSchema();
var session = ((XPObjectSpace)ObjectSpace).Session;
if (session.FindObject <SerializationConfigurationGroup>(@group => @group.Name == "Dynamic Assembly Master Detail") == null)
{
var importEngine = new ImportEngine();
importEngine.ImportObjects(new UnitOfWork(session.DataLayer), GetType(), "DynamicAssemblyMasterDetailGroup.xml");
importEngine.ImportObjects(new UnitOfWork(session.DataLayer), GetType(), "DynamicAssemblyMasterDetailModel.xml");
importEngine.ImportObjects(new UnitOfWork(session.DataLayer), GetType(), "DynamicAssemblyMasterDetailModelGroup.xml");
}
}
void Import()
{
var session = ((XPObjectSpace)ObjectSpace).Session;
if (session.FindObject <Analysis>(analysis => analysis.Name == "Controlling Grid Settings") == null)
{
var importEngine = new ImportEngine();
Stream stream = GetType().Assembly.GetManifestResourceStream(GetType(), "AnalysisObjects.xml");
importEngine.ImportObjects(stream, new UnitOfWork(session.DataLayer));
stream = GetType().Assembly.GetManifestResourceStream(GetType(), "AnalysisObjectsConfiguration.xml");
importEngine.ImportObjects(stream, new UnitOfWork(session.DataLayer));
}
}
private void uiFromFlags(ImportEngine eng)
{
foreach (var c in grpFlags.Controls)
{
CheckBox cb = c as CheckBox;
if (cb == null)
{
continue;
}
_ImportFlags flag = Invariant.ToEnum <_ImportFlags>(cb.Text);
cb.Checked = (eng.ImportFlags & flag) != 0;
}
}
public override void UpdateDatabaseAfterUpdateSchema()
{
base.UpdateDatabaseAfterUpdateSchema();
var session = ((XPObjectSpace)ObjectSpace).Session;
if (session.FindObject <SerializationConfigurationGroup>(@group => @group.Name == "Dynamic Assembly Master Detail") == null)
{
var importEngine = new ImportEngine();
var xpoTypeInfoSource = XpandModuleBase.XpoTypeInfoSource;
importEngine.ImportObjects(new XPObjectSpace(XafTypesInfo.Instance, xpoTypeInfoSource, () => new UnitOfWork(session.DataLayer)), GetType(), "DynamicAssemblyMasterDetailGroup.xml");
importEngine.ImportObjects(new XPObjectSpace(XafTypesInfo.Instance, xpoTypeInfoSource, () => new UnitOfWork(session.DataLayer)), GetType(), "DynamicAssemblyMasterDetailModel.xml");
importEngine.ImportObjects(new XPObjectSpace(XafTypesInfo.Instance, xpoTypeInfoSource, () => new UnitOfWork(session.DataLayer)), GetType(), "DynamicAssemblyMasterDetailModelGroup.xml");
}
}
/// <summary>
///加载需要导入的数据。/
/// </summary>
/// <param name="parent"></param>
/// <param name="buiObj"></param>
/// <param name="xmlFileName"></param>
/// <param name="importFile"></param>
/// <returns></returns>
public DataSet LoadImportData(IWin32Window parent, MB.WinBase.IFace.IClientRule buiObj, string xmlFileName, string importFile)
{
try {
MB.WinBase.IFace.IForm iForm = parent as MB.WinBase.IFace.IForm;
if (iForm != null)
{
_ClientRuleObject = iForm.ClientRuleObject;
}
var colPropertys = MB.WinBase.LayoutXmlConfigHelper.Instance.GetColumnPropertys(xmlFileName);
var editCols = MB.WinBase.LayoutXmlConfigHelper.Instance.GetColumnEdits(colPropertys, xmlFileName);
DataSet dsData = createNULLDataByFieldPropertys(colPropertys);
if (importFile.EndsWith(".txt"))
{
MB.WinEIDrive.Import.TxtImport txtImport = new MB.WinEIDrive.Import.TxtImport(dsData, importFile);
ImportEngine helper = new ImportEngine(editCols, grdCtlMain, txtImport);
helper.Commit();
}
else
{
if (ExistsRegedit() > 0)
{
MB.WinEIDrive.Import.OfficeXlsImport xlsImport = new WinEIDrive.Import.OfficeXlsImport(dsData, importFile);
ImportEngine helper = new ImportEngine(editCols, grdCtlMain, xlsImport);
helper.Commit();
}
else
{
MB.WinEIDrive.Import.XlsImport xlsImport = new MB.WinEIDrive.Import.XlsImport(dsData, importFile);
ImportEngine helper = new ImportEngine(editCols, grdCtlMain, xlsImport);
helper.Commit();
}
}
//移除空行数据
MB.Util.DataValidated.Instance.RemoveNULLRowData(dsData);
_ColPropertys = colPropertys;
_EditCols = editCols;
_CurrentImportData = dsData;
_XmlFileName = xmlFileName;
return(_CurrentImportData);
}
catch (MB.Util.APPException aEx) {
throw aEx;
}
catch (Exception ex) {
throw new MB.Util.APPException("数据导入处理有误。", MB.Util.APPMessageType.SysFileInfo, ex);
}
}
public ActionResult UploadFile(string name, string type = null)
{
string result = "";
try
{
IImportBL importBL = new ImportEngine();
result = importBL.ImportData(null, type, name);
}
catch (Exception ex)
{
throw ex;
}
return(Json(result, JsonRequestBehavior.AllowGet));
}
public void PreviewImports_ZeroCollectionImport_NonRecomposable_ShouldNotBlockChanges()
{
var exportProvider = ExportProviderFactory.CreateRecomposable();
var engine = new ImportEngine(exportProvider);
var import = ImportDefinitionFactory.Create("Value", ImportCardinality.ZeroOrMore, false, false);
var importer = PartFactory.CreateImporter(import);
engine.PreviewImports(importer, null);
exportProvider.AddExport("Value", 21);
exportProvider.AddExport("Value", 22);
exportProvider.RemoveExport("Value");
GC.KeepAlive(importer);
}
public void SatisfyImportsOnce_Unsuccessful_ShouldNotBlockChanges()
{
var exportProvider = ExportProviderFactory.CreateRecomposable();
var engine = new ImportEngine(exportProvider);
var import = ImportDefinitionFactory.Create("Value");
var importer = PartFactory.CreateImporter(import);
Assert.Throws <CompositionException>(() =>
engine.SatisfyImportsOnce(importer));
exportProvider.AddExport("Value", 22);
exportProvider.AddExport("Value", 23);
exportProvider.RemoveExport("Value");
GC.KeepAlive(importer);
}
public void SatisfyImports_MissingOptionalImport_Recomposable_ShouldNotBlockChanges()
{
var exportProvider = ExportProviderFactory.CreateRecomposable();
var engine = new ImportEngine(exportProvider);
var import = ImportDefinitionFactory.Create("Value", ImportCardinality.ZeroOrOne, true, false);
var importer = PartFactory.CreateImporter(import);
exportProvider.AddExport("Value", 20);
engine.SatisfyImports(importer);
exportProvider.AddExport("Value", 21);
exportProvider.RemoveExport("Value");
GC.KeepAlive(importer);
}
public void TestRunAdmins()
{
var eng = new ImportEngine();
var fn = IOUtils.FindFileToRoot(Assembly.GetExecutingAssembly().Location + "\\..", "runadmin.txt", FindToTootFlags.ReturnOriginal);
Console.WriteLine("Loading from {0}", fn);
var settings = new RunAdministrationSettings(eng, fn, 50, -1);
var runs = new RunAdministrations(settings);
runs.Load(fn);
runs.Save(fn + ".new");
Assert.AreEqual(17, runs.Count);
settings = new RunAdministrationSettings(eng, null, 3, -1);
runs = new RunAdministrations(settings);
var run = addRun(runs, "a", -2);
run = addRun(runs, "b", -2);
run = addRun(runs, "a", -4);
run = addRun(runs, "a", -6);
Assert.AreEqual(4, runs.Count);
Assert.AreEqual(2, runs.IndexOf(run));
run = addRun(runs, "a", -8);
Assert.AreEqual(4, runs.Count);
Assert.AreEqual(-1, runs.IndexOf(run));
run = addRun(runs, "a", -8, _ImportFlags.ImportFull);
Assert.AreEqual(4, runs.Count);
Assert.AreEqual(2, runs.IndexOf(run));
run = addRun(runs, "a", -7, _ImportFlags.ImportFull);
Assert.AreEqual(4, runs.Count);
Assert.AreEqual(1, runs.IndexOf(run));
run = addRun(runs, "a", -5);
Assert.AreEqual(4, runs.Count);
Assert.AreEqual(-1, runs.IndexOf(run));
run = addRun(runs, "a", -1);
Assert.AreEqual(4, runs.Count);
Assert.AreEqual(0, runs.IndexOf(run));
for (int i = 2; i < 10; i++)
{
run = addRun(runs, "a", -i);
Assert.AreEqual(4, runs.Count);
Assert.AreEqual(-1, runs.IndexOf(run));
}
}
public void TestCommands()
{
File.Delete(newDataRoot + "cmd-out.txt");
ImportEngine eng = new ImportEngine();
eng.Load(root + "import.xml");
var report = eng.Import("jsoncmd");
Assert.AreEqual(1, report.DatasourceReports.Count);
Assert.AreEqual(null, report.ErrorMessage);
var dsReport = report.DatasourceReports[0];
Console.WriteLine("Report: {0}", dsReport);
Assert.AreEqual(5, dsReport.Emitted);
Assert.AreEqual(4, dsReport.Added);
CheckFiles("cmd-out.txt");
}
public ImportReport Run(_ImportFlags flags, String switches, String xml, String[] activeDS, int maxAdds, int maxEmits)
{
try
{
using (ImportEngine engine = new ImportEngine())
{
engine.Switches = switches;
engine.ImportFlags = flags;
engine.Load(xml);
engine.MaxAdds = maxAdds;
engine.MaxEmits = maxEmits;
return(engine.Import(activeDS));
}
}
catch (Exception e)
{
Logs.ErrorLog.Log(e);
throw new Exception(e.Message);
}
}
public void SatisifyImportsOnce_Recomposable_ValueShouldNotChange_NoRecompositionRequested_ViaNonArgumentSignature()
{
var exportProvider = ExportProviderFactory.CreateRecomposable();
var engine = new ImportEngine(exportProvider);
exportProvider.AddExport("Value", 21);
var import = ImportDefinitionFactory.Create("Value", true);
var importer = PartFactory.CreateImporter(import);
engine.SatisfyImportsOnce(importer);
Assert.Equal(21, importer.GetImport(import));
exportProvider.ReplaceExportValue("Value", 42);
Assert.Equal(21, importer.GetImport(import));
GC.KeepAlive(importer);
}
