private void verfiyValueList(SIEEFieldlist fieldlist, string fieldname, string value, int count)
{
SIEEField field = fieldlist.GetFieldByName(fieldname);
Assert.AreEqual(value, field.Value);
Assert.AreEqual(count, field.ValueList.Count);
}
public override void Reload()
{
Fields.Clear();
EECWriterSettings writerSettings = (EECWriterSettings)control.ExportDestinationSettings;
SIEEFieldlist fieldlist = writerSettings.CreateSchema();
if (fieldlist == null)
{
throw (new Exception("No valid definition to create schema"));
}
foreach (SIEEField field in fieldlist)
{
if (field is SIEETableField)
{
CustomExportDestinationTable newTable = new CustomExportDestinationTable(field.Name);
newTable.ExternalId = field.ExternalId;
foreach (SIEEField columnField in ((SIEETableField)field).Columns)
{
CustomExportDestinationField newCol = new CustomExportDestinationField(columnField.Name);
newCol.ExternalId = columnField.ExternalId;
newTable.Fields.Add(newCol);
}
Fields.Add(newTable);
}
else
{
CustomExportDestinationField newField = new CustomExportDestinationField(field.Name);
newField.ExternalId = field.ExternalId;
Fields.Add(newField);
}
}
}
public SIEEFieldlist CreateSchemaAndRectifyFieldNames()
{
SIEEFieldlist schema = CreateSchema();
schema.MakeFieldnamesOCCCompliant();
return(schema);
}
private SIEEFieldlist GetFieldlistFromUI()
{
TextBox tb;
DataGridView dgv;
SIEEFieldlist fl = new SIEEFieldlist(schema);
SIEETableFieldRow tfr;
foreach (SIEEField f in fl)
{
Control c = tb_dict[f.Name];
if (c is TextBox)
{
tb = (TextBox)c;
f.Value = tb.Text;
continue;
}
// else c is DataGridView
dgv = (DataGridView)c;
SIEETableField tf = (SIEETableField)f;
DataTable table = gridToTableMap[dgv];
foreach (DataRow row in table.Rows)
{
tfr = new SIEETableFieldRow();
foreach (DataColumn col in table.Columns)
{
tfr[col.ColumnName] = row[col] is DBNull ? "" : (string)row[col];
}
tf.AddRow(tfr);
}
}
return(fl);
}
public Capture(SIEESettings settings, SIEEFieldlist schema)
{
InitializeComponent();
this.settings = settings;
this.schema = schema;
addFields(schema);
}
public SIEETableField(SIEETableField tf) : base(tf)
{
Columns = new SIEEFieldlist();
foreach (SIEEField f in tf.Columns)
{
Columns.Add(new SIEEField(f));
}
}
public SIEETableField(string name, string externalId, string val, SIEEFieldlist columns)
: base(name, externalId, val)
{
Columns = new SIEEFieldlist();
foreach (SIEEField f in columns)
{
Columns.Add(new SIEEField(f));
}
}
private void verifySchema(SIEEFieldlist schema)
{
if (schema.Where(n => n.ExternalId == null || n.ExternalId == string.Empty).Count() > 0)
{
throw new Exception("ExternalID null or empty");
}
if (schema.Select(n => n.ExternalId).Distinct().Count() != schema.Count())
{
throw new Exception("ExternamIDs are not distinct");
}
}
private void setFieldValue(SIEEFieldlist fieldlist, Field dataPoolField)
{
// Get field mapping. Normally the field is mapped by OCC.
// For unit test it may also be set by FieldMapping4UnitTest
CustomExportDestinationField edf = null;
if (FieldMapping4UnitTest_Contains(dataPoolField.Name))
{
edf = new CustomExportDestinationField()
{
Name = dataPoolField.Name
}
}
;
else
{
edf = this.writerSettings.FieldsMapper.GetExternalField(dataPoolField);
}
if (edf == null)
{
return;
}
SIEEField field = fieldlist.GetFieldByName(edf.Name);
if (field == null)
{
return;
}
field.Value = dataPoolField.Value;
if (field.Cardinality != 0)
{
int cnt = 0;
foreach (IField f in dataPoolField.Fields)
{
if (field.Cardinality < 0 || cnt++ < field.Cardinality) // Cardinality < 0: infinite
{
field.ValueList.Add(f.Value);
}
}
if (field.Cardinality > 0 && dataPoolField.Fields.Count > field.Cardinality)
{
SIEEExport.Trace.WriteError(
"Value list truncated. Field=" + edf.Name +
" Cardinality=" + field.Cardinality +
" FieldCcount=" + dataPoolField.Fields.Count
);
}
}
}
private void btn_configure_Click(object sender, EventArgs e)
{
Configure confDlg = new Configure();
Cursor.Current = Cursors.WaitCursor;
try
{
cbox_extensionSelector_SelectedIndexChanged(null, null);
confDlg.AddControl(control);
control.Size = confDlg.Size;
// Simulate serialization by SIEE and by OCC
confDlg.Settings = (SIEESettings)SIEESerializer.Clone(settings);
string xmlString = Serializer.SerializeToXmlString(settings, System.Text.Encoding.Unicode);
if (Properties.Settings.Default.ConfigSize.Width != 0)
{
confDlg.Size = Properties.Settings.Default.ConfigSize;
}
if (confDlg.MyShowDialog() == DialogResult.OK)
{
settings = confDlg.Settings;
try
{
schema = settings.CreateSchema();
schema.MakeFieldnamesOCCCompliant();
verifySchema(schema);
lbl_message.Text = "Settings and schema";
lbl_location.Text = description.GetLocation(settings);
richTextBox_settings.Text = settings.ToString() + Environment.NewLine +
"---------------" + Environment.NewLine +
schema.ToString(data: false) + Environment.NewLine +
"---------------" + Environment.NewLine +
"Location = " + description.GetLocation(settings);
btn_export.Enabled = false;
btn_capture.Enabled = true;
lbl_status.Text = "Configuration ready";
}
catch (Exception e1)
{
MessageBox.Show("Error loading configuration\n" + e1.Message);
}
Properties.Settings.Default.ConfigSize = confDlg.Size;
saveCurrentSettings();
}
}
finally { Cursor.Current = Cursors.Default; }
}
public void t01_EmptyFieldHandling()
{
// First we create the runtime document that is to be exported.
DataPool pool = createDataPool();
Document doc = pool.RootNode.Documents[0];
doc.Fields["field1"].Value = "field1value"; // should show up
doc.Fields.Add(new Field(pool, "field2", "field2value")); // should be ignored
doc.Fields.Add(new Field(pool, "field3", "field3value")); // should be ignored
// Create an xml document from the data pool
XmlDocument data = pool.RootNode.InnerXmlNode.OwnerDocument;
EECWriterSettings adapterSettings = createWriterSettings(new SIEEFieldlist()
{
{ new SIEEField()
{
Name = "field1", ExternalId = ""
} },
{ new SIEEField()
{
Name = "field2", ExternalId = ""
} },
{ new SIEEField()
{
Name = "field3", Value = "default value dor field3"
} }
});
SIEEWriterExport adapterExport = new SIEEWriterExport();
adapterExport.FieldMapping4UnitTest.Add("field1"); // we just want to simulate one mapped field
adapterExport.Configure(adapterSettings);
SIEEFieldlist lastFieldList = null;
Test_SIEEExport.ExportFunc = (settings, document, name, fl) =>
{
lastFieldList = fl;
};
adapterExport.transform(data, null); // do the export
// The test export actually has not exported anything but stored the field list internally.
// We execute the assertions on this result field list.
SIEEFieldlist fieldlist = lastFieldList;
Assert.AreEqual("field1value", fieldlist.Where(n => n.Name == "field1").First().Value, "field1 != null");
Assert.IsNull(fieldlist.Where(n => n.Name == "field2").First().Value, "field2 == null");
Assert.AreEqual("default value dor field3", fieldlist.Where(n => n.Name == "field3").First().Value, "field3 has default value");
}
public class Test_SIEESettings : SIEESettings { } // just there to index the SIEE_FactoryManager
private EECWriterSettings createWriterSettings(SIEEFieldlist schema)
{
EECWriterSettings adapterSettings = new EECWriterSettings();
adapterSettings.SerializedSchema = SIEESerializer.ObjectToString(schema);
Test_SIEESettings myTestSettings = new Test_SIEESettings();
adapterSettings.SettingsTypename = myTestSettings.GetType().ToString();
string xmlString = Serializer.SerializeToXmlString(myTestSettings, System.Text.Encoding.Unicode);
adapterSettings.SerializedSettings = SIEESerializer.ObjectToString(xmlString);
adapterSettings.FieldsMapper = new CustomFieldsMapper(); // (Empty), does nothing but must he there
return(adapterSettings);
}
public SIEEFieldlist(SIEEFieldlist fl)
{
foreach (SIEEField f in fl)
{
if (f is SIEETableField)
{
Add(new SIEETableField((SIEETableField)f));
}
else
{
Add(new SIEEField(f));
}
}
}
public SIEEFieldlist CreateSchema()
{
GetEmbeddedSettings(); // get latest settings
if (sieeSettings == null)
{
return(null);
}
SIEEFieldlist schema = sieeSettings.CreateSchemaAndRectifyFieldNames();
SerializedSchema = SIEESerializer.ObjectToString(schema);
SetEmbeddedSettings(sieeSettings); // settings may have changed during schema creation
return(schema);
}
public static void setDefaults(string type, SIEEFieldlist fieldlist, SIEEDefaultValues defaultFieldValues)
{
foreach (SIEEField field in fieldlist)
{
if (!defaultFieldValues.Exists(type, field.Name))
{
continue;
}
field.Value = defaultFieldValues.Get(type, field.Name);
if (field is SIEETableField)
{
((SIEETableField)field).Set_tabValue(field.Value);
continue;
}
}
}
private void MakeFieldNamesUnique(SIEEFieldlist fields)
{
foreach (SIEEField field in fields)
{
int cnt = 0;
foreach (SIEEField f1 in fields)
{
if (field.Equals(f1))
{
continue;
}
if (field.Name == f1.Name)
{
f1.Name += "_" + cnt++.ToString();
}
}
}
}
public void t04_DocumentNameComposer_Basic()
{
SIEEFieldlist fl = new SIEEFieldlist();
var td = new[]
{
new { n = 01, spec = @"abc", result = @"abc" },
new { n = 02, spec = @"a\\bc", result = @"a\bc" },
new { n = 03, spec = @"a\bc", result = @"a\bc" },
new { n = 04, spec = @"a\<bc", result = @"a<bc", },
new { n = 05, spec = @"abc\", result = @"abc\" },
new { n = 10, spec = @"abc_<:Field_1>_def", result = @"abc_Hello_def" },
new { n = 11, spec = @"abc_<unknown>_def", result = @"abc_<unknown>_def" },
new { n = 12, spec = @"<:Field_1> <:Field_2>", result = @"Hello World" },
new { n = 13, spec = @"<:Field_1>", result = @"Hello" },
new { n = 20, spec = @"x<:Field_1", result = @"x<:Field_1" },
new { n = 21, spec = @"<:Field_1", result = @"<:Field_1" },
new { n = 22, spec = @"<<:Field_1>", result = @"<<:Field_1>" },
new { n = 30, spec = @"abc\>de", result = @"abc\>de" },
new { n = 31, spec = @"abc\\de", result = @"abc\de" },
};
List <KeyValuePair <string, string> > valueList = new List <KeyValuePair <string, string> >();
valueList.Add(new KeyValuePair <string, string>("Field_1", "Hello"));
valueList.Add(new KeyValuePair <string, string>("Field_2", "World"));
NameSpecParser nsp = new NameSpecParser("", "", valueList);
int doOnly = 0;
for (int i = 0; i != td.Length; i++)
{
if (doOnly != 0 && td[i].n != doOnly)
{
continue;
}
string result = nsp.Convert(td[i].spec);
Assert.AreEqual(td[i].result, result, td[i].n + ": Value");
}
Assert.AreEqual(0, doOnly, "Not all batches executed");
}
public void MakeFieldnamesOCCCompliant()
{
foreach (SIEEField field in this)
{
field.Name = ConvertToLegalOCCFieldname(field.Name);
}
MakeFieldNamesUnique(this);
foreach (SIEEField field in this)
{
if (field is SIEETableField)
{
SIEETableField tablefield = (SIEETableField)field;
SIEEFieldlist columns = tablefield.Columns;
foreach (SIEEField f1 in columns)
{
f1.Name = ConvertToLegalOCCFieldname(f1.Name);
}
MakeFieldNamesUnique(columns);
tablefield.Columns = columns;
}
}
}
public void t03_WorkWithSchema()
{
SIEEFieldlist schema = new SIEEFieldlist();
Assert.IsNotNull(schema);
schema.Add(new SIEEField("1", "ex1", "value1"));
schema.Add(new SIEEField("2", "ex2", "value2"));
schema.Add(new SIEEField("3", "ex3", "value3"));
bool b = schema.Exists("2");
Assert.IsTrue(b);
SIEEField f = schema.GetFieldByName("2");
Assert.AreEqual("2", f.Name);
f = schema.GetFieldByName("x");
Assert.IsNull(f);
schema.MakeFieldnamesOCCCompliant();
}
public void t02_SerializeSchemaToXML()
{
SIEEFieldlist s1 = new SIEEFieldlist();
s1.Add(new SIEEField("1", "ex1", "value1"));
s1.Add(new SIEEField("2", "ex2", "value2"));
s1.Add(new SIEEField("3", "ex3", "value3"));
SIEEFieldlist s2 = new SIEEFieldlist();
s2.Add(new SIEEField("1.1", "ex1.1", "value1.1"));
s2.Add(new SIEEField("1.2", "ex1.2", "value1.2"));
s1.Add(new SIEETableField("4", "ex4", "value4", s2));
string ser = Serializer.SerializeToXmlString(s1, System.Text.Encoding.Unicode);
SIEEFieldlist deser = (SIEEFieldlist)Serializer.DeserializeFromXmlString(ser, typeof(SIEEFieldlist), System.Text.Encoding.Unicode);
SIEEField f1 = deser.GetFieldByName("1");
Assert.AreEqual("value1", f1.Value);
SIEEField f2 = deser.GetFieldByName("2");
Assert.AreEqual("2", f2.Name);
SIEEField f3 = deser.GetFieldByName("3");
Assert.AreEqual("ex3", f3.ExternalId);
SIEETableField f4 = deser.GetFieldByName("4") as SIEETableField;
Assert.AreEqual("ex4", f4.ExternalId);
SIEEField f5 = f4.Columns[0];
Assert.AreEqual("value1.1", f5.Value);
}
public void t08_SIEESerializer()
{
// Create fieldlist
SIEEFieldlist fieldlist = new SIEEFieldlist();
fieldlist.Add(new SIEEField {
Name = "Field_1", ExternalId = "Ext_1"
});
fieldlist.Add(new SIEEField {
Name = "Field_2", ExternalId = "Ext_2"
});
SIEETableField tf = new SIEETableField {
Name = "Table", ExternalId = "Ext_Table"
};
tf.Columns.Add(new SIEEField {
Name = "TabField_1", ExternalId = "TabExt_1"
});
tf.Columns.Add(new SIEEField {
Name = "TabField_2", ExternalId = "TabExt_2"
});
fieldlist.Add(tf);
// Serialize
string s1 = SIEESerializer.ObjectToString(fieldlist);
// Deserialize
SIEEFieldlist f1 = (SIEEFieldlist)SIEESerializer.StringToObject(s1);
// Serialize the newly created field list
string s2 = SIEESerializer.ObjectToString(f1);
// final compare
string txt1 = fieldlist.ToString(data: false);
string txt2 = f1.ToString(data: false);
Assert.AreEqual(s1, s2);
}
/// This is the core function that copies the field values from an OCC datapool document into an SIEEFieldlist.
/// Input is a fieldlist as derived from the Schema. This means it contains all Schema fields. In the document
/// there may (a) be additional fields and (b) the might be no field connected to a given Schema field.
/// Additional fields are simply ingnored. Fields in the fieldlist that have no correspondence in the document
/// are left unchanged. That means, if the field has a value that that is passed to the export. Normally schema
/// fields should have "null" assigned to the Value property of a fields. The SIEEExport function needs to
/// handle this case.
private SIEEDocument documentToFieldlist(SIEEFieldlist fieldlist, Document doc, string batchId, string profile)
{
CustomExportDestinationField edf;
CustomExportDestinationTable edt;
foreach (Field dataPoolField in doc.Fields)
{
if (dataPoolField is LookupList)
{
foreach (Field dataPoolSubfield in dataPoolField.Fields)
{
setFieldValue(fieldlist, dataPoolSubfield);
}
continue;
}
if (dataPoolField is Table)
{
edt = this.writerSettings.FieldsMapper.GetExternalTable((Table)dataPoolField);
if (edt == null)
{
continue;
}
SIEETableField tf = (SIEETableField)fieldlist.GetFieldByName(edt.Name);
if (tf == null)
{
continue;
}
FieldCollection rows = ((Table)dataPoolField).Rows;
for (int i = 0; i != rows.Count; i++)
{
TableRow r = (TableRow)rows[i];
SIEETableFieldRow tf_row = new SIEETableFieldRow();
foreach (Field col in r.Columns)
{
edf = this.writerSettings.FieldsMapper.GetExternalTableCell(((Table)dataPoolField), col);
if (edf == null)
{
continue;
}
if (tf.ColumnExists(edf.Name))
{
tf_row.Add(edf.Name, col.Value);
}
}
tf.AddRow(tf_row);
}
continue;
}
// regular field
setFieldValue(fieldlist, dataPoolField);
}
SIEEFieldlist auxFields = new SIEEFieldlist();
foreach (Field dataPoolField in doc.Fields)
{
if (!(dataPoolField is LookupList) && !(dataPoolField is Table))
{
auxFields.Add(new SIEEField(dataPoolField.Name, null, dataPoolField.Value));
}
}
SourceInstance[] si = doc.GetInputSourceInstances();
Annotation a = doc.Annotations["exportName"];
SIEEDocument document = new SIEEDocument()
{
Fieldlist = fieldlist,
AuxFields = auxFields,
PDFFileName = doc.GetExportPdfSource().Url,
InputFileName = si.Length > 0 ? doc.GetInputSourceInstances()[0].Id : "",
BatchId = batchId,
ScriptingName = a?.Value,
Profile = profile,
};
return(document);
}
public override XmlDocument transform(XmlDocument data, IParameters parameters)
{
// The SIEEBatch is created from the schema as defined in the setting object. It contains all
// fields regardless of whether they have been mapped to OCC fields.
SIEEFieldlist schema = (SIEEFieldlist)SIEESerializer.StringToObject(writerSettings.SerializedSchema);
// This class has no initialization by which the factory could be set beforehand. We therefore
// load the factory from the SIEE_FactoryManager. (This was the only reason to invent the
// SIEE_FactoryManager in the first place.
SIEEFactory factory = SIEEFactoryManager.GetFromSettingsTypename(writerSettings.SettingsTypename);
writerSettings.SetFactory(factory);
// Create the SIEE objects wee need
SIEEExport myExport = factory.CreateExport();
SIEEDescription description = factory.CreateDescription();
DataPool pool = new DataPool(data);
SIEEBatch batch = new SIEEBatch();
int maxRetryCount = description.NumberOfRetries;
string batchId = pool.RootNode.Fields["cc_BatchId"].Value;
string profile = pool.RootNode.Fields["cc_ProfileName"].Value;
SIEEExport.Trace.WriteInfo("Start exporting batch " + batchId);
ExportStateParams exportStateParams = null;
Dictionary <SIEEDocument, Document> siee2dataPool = new Dictionary <SIEEDocument, Document>();
Dictionary <SIEEDocument, int> annotationNumber = new Dictionary <SIEEDocument, int>();
for (int i = 0; i < pool.RootNode.Documents.Count; i++)
{
Document document = pool.RootNode.Documents[i];
SIEEDocument sieeDocument = documentToFieldlist(new SIEEFieldlist(schema), document, batchId, profile);
sieeDocument.DocumentId = String.Format("{0:D4}", i);
sieeDocument.DocumentClass = document.Name;
sieeDocument.SIEEAnnotation = sieeDocument.NewSIEEAnnotation = null;
int anNo = findAnnotation(document);
annotationNumber[sieeDocument] = anNo;
if (anNo != 0)
{
sieeDocument.SIEEAnnotation = document.Annotations[annotationName(anNo - 1)].Value;
}
exportStateParams = DataPoolWorkflowStateExtensions.GetExportStateParams(document);
// Process only documents with state "ToBeProcessed" (not yet exported documents or documents whose export failed).
if (exportStateParams.state == ExportState.ToBeProcessed)
{
siee2dataPool[sieeDocument] = document;
batch.Add(sieeDocument);
}
}
try
{
SIEESettings settings = writerSettings.GetEmbeddedSettings();
myExport.ExportBatch(settings, batch);
}
catch (Exception e)
{
SIEEExport.Trace.WriteError("SIEEWriterExport: Batch " + batchId + " failed", e);
throw;
}
foreach (SIEEDocument doc in batch)
{
Document occDocument = siee2dataPool[doc];
int anNo = annotationNumber[doc];
if (doc.NewSIEEAnnotation != null)
{
occDocument.Annotations.Add(new Annotation(pool, annotationName(anNo), doc.NewSIEEAnnotation));
}
exportStateParams = DataPoolWorkflowStateExtensions.GetExportStateParams(occDocument);
if (doc.Succeeded)
{
occDocument.Annotations.Add(new Annotation(pool, "TargetDocumentId", doc.TargetDocumentId));
occDocument.Annotations.Add(new Annotation(pool, "TargetType", description.TypeName));
exportStateParams.state = ExportState.Succeeded;
}
else
{
exportStateParams.message = "Export failed: " + doc.ErrorMsg;
if (doc.NonRecoverableError)
{
throw new Exception("Fatal export error: " + doc.ErrorMsg);
}
}
// Set delay time for start of retry
if (exportStateParams.repetitionCount == 0)
{
exportStateParams.delaySeconds = description.StartTimeForRetry;
}
DataPoolWorkflowStateExtensions.HandleExportStateParams(occDocument, maxRetryCount, exportStateParams);
}
SIEEExport.Trace.WriteInfo("Done exporting batch " + batchId);
return(data);
}
public abstract void ExportDocument(SIEESettings settings, SIEEDocument document, string name, SIEEFieldlist fieldlist);
public SIEETableField()
{
Columns = new SIEEFieldlist();
}
private void addFields(SIEEFieldlist fl)
{
Label l;
TextBox tb;
DataGridView dgv;
DataTable table;
int ypos = 0;
const int labelwidth = 300;
int labelheight;
int entryheight;
int gridheight;
int cnt = 0;
tb_dict.Clear();
foreach (SIEEField f in fl)
{
l = new Label();
l.Location = new System.Drawing.Point(0, ypos);
l.Name = "label_" + f.Name;
labelheight = l.Size.Height;
l.Size = new System.Drawing.Size(labelwidth, labelheight);
l.TabIndex = cnt;
l.Text = f.Name;
this.panel.Controls.Add(l);
if (!(f is SIEETableField))
{
tb = new TextBox();
tb.Location = new System.Drawing.Point(labelwidth + 30, ypos);
tb.Name = f.Name;
entryheight = tb.Size.Height > labelheight ? tb.Size.Height : labelheight;
tb.Size = new System.Drawing.Size(panel.Size.Width - (labelwidth + 30), entryheight);
tb.TabIndex = cnt;
this.panel.Controls.Add(tb);
tb_dict.Add(f.Name, tb);
tb.Anchor = AnchorStyles.Top | AnchorStyles.Right | AnchorStyles.Left;
ypos += entryheight;
}
else
{
SIEETableField tf = (SIEETableField)f;
dgv = new DataGridView();
dgv.Location = new System.Drawing.Point(labelwidth + 30, ypos);
dgv.Name = tf.Name;
gridheight = dgv.Size.Height;
dgv.Size = new System.Drawing.Size(panel.Size.Width - (labelwidth + 30), gridheight);
dgv.TabIndex = cnt;
dgv.Font = new System.Drawing.Font("Courier New", 9F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
table = new DataTable();
gridToTableMap[dgv] = table;
dgv.DataSource = table;
foreach (SIEEField col in tf.Columns)
{
table.Columns.Add(col.Name);
}
this.panel.Controls.Add(dgv);
tb_dict.Add(f.Name, dgv);
dgv.Anchor = AnchorStyles.Top | AnchorStyles.Right | AnchorStyles.Left;
//dgv.AutoResizeColumns(DataGridViewAutoSizeColumnsMode.Fill);
ypos += 10 + gridheight;
}
cnt++;
}
}
public override void ExportDocument(SIEESettings settings, SIEEDocument document, string name, SIEEFieldlist fieldlist)
{
ExportFunc(settings, document, name, fieldlist);
}
public void t10_ListFieldHandling()
{
// First we create the runtime document that is to be exported.
DataPool pool = createDataPool();
Document doc = pool.RootNode.Documents[0];
doc.Fields["field1"].Value = "field1value";
doc.Fields.Add(new Field(pool, "field2", "field2value"));
doc.Fields.Add(new Field(pool, "field3", "field3value"));
doc.Fields.Add(new Field(pool, "field4", "field4value"));
doc.Fields.Add(new Field(pool, "field5", "field5value"));
doc.Fields.Add(new Field(pool, "field6", "field6value"));
addFieldList(pool, doc.Fields["field1"], 2); // to ba ignored
// field2 --> no list
addFieldList(pool, doc.Fields["field3"], 2); // fewer subfields
addFieldList(pool, doc.Fields["field4"], 4); // exact
addFieldList(pool, doc.Fields["field5"], 6); // more sub fields
addFieldList(pool, doc.Fields["field6"], 42); // no limits
// Create an xml document from the data pool
XmlDocument data;
data = pool.RootNode.InnerXmlNode.OwnerDocument;
EECWriterSettings adapterSettings = createWriterSettings(new SIEEFieldlist()
{
{ new SIEEField()
{
Name = "field1",
} },
{ new SIEEField()
{
Name = "field2", Cardinality = 2
} },
{ new SIEEField()
{
Name = "field3", Cardinality = 3
} },
{ new SIEEField()
{
Name = "field4", Cardinality = 4
} },
{ new SIEEField()
{
Name = "field5", Cardinality = 5
} },
{ new SIEEField()
{
Name = "field6", Cardinality = -1
} },
});
SIEEWriterExport adapterExport = new SIEEWriterExport();
adapterExport.FieldMapping4UnitTest.Add("field1");
adapterExport.FieldMapping4UnitTest.Add("field2");
adapterExport.FieldMapping4UnitTest.Add("field3");
adapterExport.FieldMapping4UnitTest.Add("field4");
adapterExport.FieldMapping4UnitTest.Add("field5");
adapterExport.FieldMapping4UnitTest.Add("field6");
adapterExport.Configure(adapterSettings);
SIEEFieldlist lastFieldList = null;
Test_SIEEExport.ExportFunc = (settings, document, name, fl) =>
{
lastFieldList = fl;
};
adapterExport.transform(data, null); // do the export
// The test export actually has not exported anything but stored the field list internally.
// We execute the assertions on this result field list.
SIEEFieldlist fieldlist = lastFieldList;
verfiyValueList(lastFieldList, "field1", "field1value", 0);
verfiyValueList(lastFieldList, "field2", "field2value", 0);
verfiyValueList(lastFieldList, "field3", "field3value", 2);
verfiyValueList(lastFieldList, "field4", "field4value", 4);
verfiyValueList(lastFieldList, "field5", "field5value", 5);
verfiyValueList(lastFieldList, "field6", "field6value", 42);
}
