public void TestWriteStructures(string file)
{
var structureReader = new StructureParsingManager();
var fileInfo = new FileInfo(file);
IStructureWorkspace structureWorkspace;
using (var readable = new FileReadableDataLocation(fileInfo))
{
structureWorkspace = structureReader.ParseStructures(readable);
}
ISdmxObjects structureBeans = structureWorkspace.GetStructureObjects(false);
string output = string.Format(CultureInfo.InvariantCulture, "test-sdmxv2.1-{0}", fileInfo.Name);
var writtingManager = new StructureWriterManager();
using (var outputStream = new FileStream(output, FileMode.Create))
{
writtingManager.WriteStructures(structureBeans, new SdmxStructureFormat(StructureOutputFormat.GetFromEnum(StructureOutputFormatEnumType.SdmxV21StructureDocument)), outputStream);
}
using (var readable = new FileReadableDataLocation(output))
{
XMLParser.ValidateXml(readable, SdmxSchemaEnumType.VersionTwoPointOne);
var structures = structureReader.ParseStructures(readable);
Assert.NotNull(structures);
}
}
public void TestBuild()
{
IStructureParsingManager manager = new StructureParsingManager();
IDataQueryParseManager queryParseManager = new DataQueryParseManager(SdmxSchemaEnumType.VersionTwoPointOne);
IComplexDataQueryBuilderManager dataQueryBuilderManager = new ComplexDataQueryBuilderManager(new ComplexDataQueryFactoryV21());
IDataflowObject dataFlow;
IDataStructureObject dsd;
using (var readable = new FileReadableDataLocation("tests/V21/Structure/test-sdmxv2.1-ESTAT+SSTSCONS_PROD_M+2.0.xml"))
{
var structureWorkspace = manager.ParseStructures(readable);
dataFlow = structureWorkspace.GetStructureObjects(false).Dataflows.First();
}
using (var readable = new FileReadableDataLocation("tests/V21/Structure/test-sdmxv2.1-ESTAT+STS+2.0.xml"))
{
var structureWorkspace = manager.ParseStructures(readable);
dsd = structureWorkspace.GetStructureObjects(false).DataStructures.First();
}
ISet<IComplexDataQuerySelection> sections = new HashSet<IComplexDataQuerySelection>();
var freqCriteria = new ComplexDataQuerySelectionImpl("FREQ", new IComplexComponentValue[] { new ComplexComponentValueImpl("M", OrderedOperator.GetFromEnum(OrderedOperatorEnumType.Equal), SdmxStructureEnumType.Dimension), new ComplexComponentValueImpl("A", OrderedOperator.GetFromEnum(OrderedOperatorEnumType.NotEqual), SdmxStructureEnumType.Dimension), new ComplexComponentValueImpl("B", OrderedOperator.GetFromEnum(OrderedOperatorEnumType.Equal), SdmxStructureEnumType.Dimension) });
sections.Add(freqCriteria);
var adjustmentCriteria = new ComplexDataQuerySelectionImpl("ADJUSTMENT", new IComplexComponentValue[] { new ComplexComponentValueImpl("01", OrderedOperator.GetFromEnum(OrderedOperatorEnumType.NotEqual), SdmxStructureEnumType.Dimension) });
sections.Add(adjustmentCriteria);
var titleCriteria = new ComplexDataQuerySelectionImpl(
"TITLE",
new IComplexComponentValue[] { new ComplexComponentValueImpl("PAOKARA", TextSearch.GetFromEnum(TextSearchEnumType.Contains), SdmxStructureEnumType.DataAttribute), new ComplexComponentValueImpl("ARIS", TextSearch.GetFromEnum(TextSearchEnumType.DoesNotContain), SdmxStructureEnumType.DataAttribute), });
sections.Add(titleCriteria);
OrderedOperator equalOperator = OrderedOperator.GetFromEnum(OrderedOperatorEnumType.Equal);
var dateFrom = new SdmxDateCore("2000-01");
var dateFromOperator = OrderedOperator.GetFromEnum(OrderedOperatorEnumType.GreaterThanOrEqual);
var primaryMeasureValue = new ComplexComponentValueImpl("200.20", OrderedOperator.GetFromEnum(OrderedOperatorEnumType.GreaterThan), SdmxStructureEnumType.PrimaryMeasure);
ICollection<IComplexDataQuerySelectionGroup> collection = new[] { new ComplexDataQuerySelectionGroupImpl(sections, dateFrom, dateFromOperator, null, equalOperator, new HashSet<IComplexComponentValue> { primaryMeasureValue }) };
var complexDataQueryImpl = new ComplexDataQueryImpl(
null,
null,
null,
dsd,
dataFlow,
null,
null,
0,
null,
false,
null,
DimensionAtObservation.GetFromEnum(DimensionAtObservationEnumType.Time).Value,
false,
DataQueryDetail.GetFromEnum(DataQueryDetailEnumType.Full),
collection);
var dataQuery = this._builder.Build(complexDataQueryImpl);
Assert.NotNull(dataQuery);
}
public void TestComposites(string file)
{
var structureParsing = new StructureParsingManager(SdmxSchemaEnumType.VersionTwo);
using (var readable = new FileReadableDataLocation(file))
{
IStructureWorkspace structureWorkspace = structureParsing.ParseStructures(readable);
ISdmxObjects objects = structureWorkspace.GetStructureObjects(false);
foreach (IMaintainableObject maintainableObject in objects.GetAllMaintainables())
{
ISet<ISdmxObject> sdmxObjects = maintainableObject.Composites;
Assert.IsNotEmpty(sdmxObjects);
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="TestComplexDataQueryToXDoc"/> class.
/// </summary>
public TestComplexDataQueryToXDoc()
{
IStructureParsingManager manager = new StructureParsingManager();
this._dataQueryBuilderManager = new ComplexDataQueryBuilderManager(new ComplexDataQueryFactoryV21());
using (var readable = new FileReadableDataLocation("tests/V21/Structure/test-sdmxv2.1-ESTAT+SSTSCONS_PROD_M+2.0.xml"))
{
var structureWorkspace = manager.ParseStructures(readable);
this._dataflowObject = structureWorkspace.GetStructureObjects(false).Dataflows.First();
}
using (var readable = new FileReadableDataLocation("tests/V21/Structure/test-sdmxv2.1-ESTAT+STS+2.0.xml"))
{
var structureWorkspace = manager.ParseStructures(readable);
this._dataStructureObject = structureWorkspace.GetStructureObjects(false).DataStructures.First();
}
}
/// <summary>
/// The read structure workspace.
/// </summary>
/// <param name="sdmxVersion">
/// The SDMX Version.
/// </param>
/// <param name="file">
/// The file.
/// </param>
/// <param name="test">
/// The test.
/// </param>
protected static void ReadStructureWorkspace(SdmxSchemaEnumType sdmxVersion, string file, Action<ISdmxObjects> test)
{
IStructureParsingManager parsingManager = new StructureParsingManager(sdmxVersion);
var sw = new Stopwatch();
sw.Start();
ISdmxObjects structureBeans;
using (IReadableDataLocation fileReadableDataLocation = new FileReadableDataLocation(file))
{
IStructureWorkspace structureWorkspace = parsingManager.ParseStructures(fileReadableDataLocation);
Assert.NotNull(structureWorkspace);
structureBeans = structureWorkspace.GetStructureObjects(false);
Assert.NotNull(structureBeans);
}
sw.Stop();
Trace.WriteLine(string.Format(CultureInfo.InvariantCulture, "StructureParser : Reading {0} took {1}", file, sw.Elapsed));
test(structureBeans);
}
public void TestBuildSuccessResponseFile(SdmxSchemaEnumType version, string file)
{
var responseBuilder = new SubmitStructureResponseBuilder();
ISdmxObjects sdmxObjects;
using (IReadableDataLocation dataLocation = new FileReadableDataLocation(file))
{
StructureParsingManager parsingManager = new StructureParsingManager();
var structureWorkspace = parsingManager.ParseStructures(dataLocation);
sdmxObjects = structureWorkspace.GetStructureObjects(false);
}
var output = responseBuilder.BuildSuccessResponse(sdmxObjects, SdmxSchema.GetFromEnum(version));
var fileName = "TestBuildSuccessResponse" + version + ".xml";
output.Untyped.Save(fileName);
using (IReadableDataLocation dataLocation = new FileReadableDataLocation(fileName))
{
XMLParser.ValidateXml(dataLocation, version);
}
}
/// <summary>
/// The main.
/// </summary>
/// <param name="args">
/// The args.
/// </param>
/// <exception cref="InvalidOperationException">
/// Could not load Structure objects
/// </exception>
public static void Main(string[] args)
{
// 1. Initialize the StructureParsingManager. This implementation supports both 2.0 and 2.1.
IStructureParsingManager parsingManager = new StructureParsingManager(SdmxSchemaEnumType.VersionTwo);
// 2. open IReadableDataLocation
using (IReadableDataLocation dataLocation = new FileReadableDataLocation("ESTAT_CPI_v1.0.xml"))
{
// 3. Get the IStructureWorkspace
IStructureWorkspace structureWorkspace = parsingManager.ParseStructures(dataLocation);
// 4. Get the ISdmxObjects without resolving cross-references.
ISdmxObjects structureObjects = structureWorkspace.GetStructureObjects(false);
if (structureObjects == null)
{
throw new InvalidOperationException("Could not load Structure objects");
}
}
}
public void TestDownload(string dsd, string dataflow, string query)
{
IStructureParsingManager parsingManager = new StructureParsingManager();
ISdmxObjects objects = new SdmxObjectsImpl();
using (IReadableDataLocation location = new FileReadableDataLocation(dsd))
{
objects.Merge(parsingManager.ParseStructures(location).GetStructureObjects(false));
}
using (IReadableDataLocation location = new FileReadableDataLocation(dataflow))
{
objects.Merge(parsingManager.ParseStructures(location).GetStructureObjects(false));
}
ISdmxObjectRetrievalManager retrievalManager = new InMemoryRetrievalManager(objects);
IList<IDataQuery> buildDataQuery;
IDataQueryParseManager parseManager = new DataQueryParseManager(SdmxSchemaEnumType.VersionTwo);
using (IReadableDataLocation readable = new FileReadableDataLocation(query))
{
// call BuildDataQuery to process the query.xml and get a list of IDataQuery
buildDataQuery = parseManager.BuildDataQuery(readable, retrievalManager);
}
IList<IDataQuery> buildDataQuery1;
foreach (var dataQuery in buildDataQuery)
{
IDataQueryBuilderManager dataQueryBuilderManager = new DataQueryBuilderManager(new DataQueryFactory());
var xdoc = dataQueryBuilderManager.BuildDataQuery(dataQuery, new QueryMessageV2Format());
Assert.IsNotNull(xdoc);
MemoryStream xmlStream = new MemoryStream();
xdoc.Save(xmlStream);
using (IReadableDataLocation readable = new MemoryReadableLocation(xmlStream.ToArray()))
{
// call BuildDataQuery to process the xmlStream and get a list of IDataQuery
buildDataQuery1 = parseManager.BuildDataQuery(readable, retrievalManager);
}
Assert.AreEqual(dataQuery.ToString(),buildDataQuery1[0].ToString());
xmlStream.Flush();
}
}
/// <summary>
/// Gets the SDMX objects.
/// </summary>
/// <returns>The <see cref="ISdmxObjects"/>.</returns>
private static ISdmxObjects GetSdmxObjects()
{
ISdmxObjects objects;
var file = new FileInfo("tests/v21/Structure/test-sdmxv2.1-ESTAT+STS+2.0.xml");
IStructureParsingManager manager = new StructureParsingManager(SdmxSchemaEnumType.Null);
using (var readable = new FileReadableDataLocation(file))
{
IStructureWorkspace structureWorkspace = manager.ParseStructures(readable);
objects = structureWorkspace.GetStructureObjects(false);
}
return objects;
}
public void TestBuildComplexDataQuery()
{
IStructureParsingManager manager = new StructureParsingManager();
IDataQueryParseManager queryParseManager = new DataQueryParseManager(SdmxSchemaEnumType.VersionTwoPointOne);
IComplexDataQueryBuilderManager dataQueryBuilderManager = new ComplexDataQueryBuilderManager(new ComplexDataQueryFactoryV21());
IDataflowObject dataFlow;
IDataStructureObject dsd;
using (var readable = new FileReadableDataLocation("tests/V21/Structure/test-sdmxv2.1-ESTAT+SSTSCONS_PROD_M+2.0.xml"))
{
var structureWorkspace = manager.ParseStructures(readable);
dataFlow = structureWorkspace.GetStructureObjects(false).Dataflows.First();
}
using (var readable = new FileReadableDataLocation("tests/V21/Structure/test-sdmxv2.1-ESTAT+STS+2.0.xml"))
{
var structureWorkspace = manager.ParseStructures(readable);
dsd = structureWorkspace.GetStructureObjects(false).DataStructures.First();
}
ISet<IComplexDataQuerySelection> sections = new HashSet<IComplexDataQuerySelection>();
var freqCriteria = new ComplexDataQuerySelectionImpl("FREQ", new IComplexComponentValue[] { new ComplexComponentValueImpl("M", OrderedOperator.GetFromEnum(OrderedOperatorEnumType.Equal), SdmxStructureEnumType.Dimension), new ComplexComponentValueImpl("A", OrderedOperator.GetFromEnum(OrderedOperatorEnumType.NotEqual), SdmxStructureEnumType.Dimension), new ComplexComponentValueImpl("B", OrderedOperator.GetFromEnum(OrderedOperatorEnumType.Equal), SdmxStructureEnumType.Dimension) });
sections.Add(freqCriteria);
var adjustmentCriteria = new ComplexDataQuerySelectionImpl("ADJUSTMENT", new IComplexComponentValue[] { new ComplexComponentValueImpl("01", OrderedOperator.GetFromEnum(OrderedOperatorEnumType.NotEqual), SdmxStructureEnumType.Dimension), new ComplexComponentValueImpl("S2", OrderedOperator.GetFromEnum(OrderedOperatorEnumType.NotEqual), SdmxStructureEnumType.Dimension) });
sections.Add(adjustmentCriteria);
var titleCriteria = new ComplexDataQuerySelectionImpl(
"TITLE",
new IComplexComponentValue[] { new ComplexComponentValueImpl("PAOKARA", TextSearch.GetFromEnum(TextSearchEnumType.Contains), SdmxStructureEnumType.DataAttribute), new ComplexComponentValueImpl("ARIS", TextSearch.GetFromEnum(TextSearchEnumType.DoesNotContain), SdmxStructureEnumType.DataAttribute) });
sections.Add(titleCriteria);
OrderedOperator equalOperator = OrderedOperator.GetFromEnum(OrderedOperatorEnumType.Equal);
var dateFrom = new SdmxDateCore("2000-01");
var dateFromOperator = OrderedOperator.GetFromEnum(OrderedOperatorEnumType.GreaterThanOrEqual);
var primaryMeasureValue = new ComplexComponentValueImpl("200.20", OrderedOperator.GetFromEnum(OrderedOperatorEnumType.GreaterThan), SdmxStructureEnumType.PrimaryMeasure);
ICollection<IComplexDataQuerySelectionGroup> collection = new[] { new ComplexDataQuerySelectionGroupImpl(sections, dateFrom, dateFromOperator, null, equalOperator, new HashSet<IComplexComponentValue> { primaryMeasureValue }) };
var complexDataQueryImpl = new ComplexDataQueryImpl(
null,
null,
null,
dsd,
dataFlow,
null,
null,
0,
null,
false,
null,
DimensionAtObservation.GetFromEnum(DimensionAtObservationEnumType.Time).Value,
false,
DataQueryDetail.GetFromEnum(DataQueryDetailEnumType.Full),
collection);
var buildComplexDataQuery = dataQueryBuilderManager.BuildComplexDataQuery(
complexDataQueryImpl, new StructSpecificDataFormatV21());
var fileName = string.Format("test-TestBuildComplexDataQuery.xml");
buildComplexDataQuery.Save(fileName);
ISdmxObjects objects = new SdmxObjectsImpl();
objects.AddDataStructure(dsd);
objects.AddDataflow(dataFlow);
ISdmxObjectRetrievalManager beanRetrievalManager = new InMemoryRetrievalManager(objects);
IComplexDataQuery query;
using (var readable = new FileReadableDataLocation(fileName))
{
XMLParser.ValidateXml(readable, SdmxSchemaEnumType.VersionTwoPointOne);
query = queryParseManager.BuildComplexDataQuery(readable, beanRetrievalManager).First();
}
Assert.AreEqual(1, query.SelectionGroups.Count);
var selectionGroup = query.SelectionGroups.First();
Assert.AreEqual(dateFrom, selectionGroup.DateFrom);
Assert.AreEqual(dateFromOperator, selectionGroup.DateFromOperator);
Assert.IsNull(selectionGroup.DateTo);
Assert.AreEqual(1, selectionGroup.PrimaryMeasureValue.Count);
var primaryValue = selectionGroup.PrimaryMeasureValue.First();
Assert.AreEqual(primaryMeasureValue.Value, primaryValue.Value);
Assert.AreEqual(primaryMeasureValue.OrderedOperator, primaryValue.OrderedOperator);
Assert.AreEqual(3, selectionGroup.Selections.Count);
var gotFreqCriteria = selectionGroup.GetSelectionsForConcept(freqCriteria.ComponentId);
Assert.AreEqual(gotFreqCriteria, freqCriteria, "FREQ diff");
var gotAdjustmentCriteria = selectionGroup.GetSelectionsForConcept(adjustmentCriteria.ComponentId);
Assert.AreEqual(gotAdjustmentCriteria, adjustmentCriteria, "ADJ diff");
Assert.IsTrue(gotAdjustmentCriteria.Values.All(value => value.OrderedOperator.EnumType == OrderedOperatorEnumType.NotEqual));
var gotTitleCriteria = selectionGroup.GetSelectionsForConcept(titleCriteria.ComponentId);
Assert.AreEqual(gotTitleCriteria, titleCriteria, "TITLE diff");
}
/// <summary>
/// Merges the specified file information.
/// </summary>
/// <param name="stream">The file information.</param>
/// <param name="sdmxObjects">The SDMX objects.</param>
private static void Merge(Stream stream, ISdmxObjects sdmxObjects)
{
IStructureWorkspace structureWorkspace;
StructureParsingManager parsingManager = new StructureParsingManager();
IReadableDataLocationFactory dataLocationFactory = new ReadableDataLocationFactory();
using (var readableDataLocation = dataLocationFactory.GetReadableDataLocation(stream))
{
structureWorkspace = parsingManager.ParseStructures(readableDataLocation);
}
sdmxObjects.Merge(structureWorkspace.GetStructureObjects(false));
}
public void TestFull(string file, string dsd)
{
var retrievalManager = new InMemoryRetrievalManager();
IDataStructureObject dsdObject;
using (IReadableDataLocation dataLocation = _factory.GetReadableDataLocation(new FileInfo(dsd)))
{
IStructureParsingManager manager = new StructureParsingManager();
var structureWorkspace = manager.ParseStructures(dataLocation);
retrievalManager.SaveStructures(structureWorkspace.GetStructureObjects(false));
}
IReportedDateEngine reportedDateEngine = new ReportedDateEngine();
var sdmxDataReaderFactory = new SdmxDataReaderFactory(new DataInformationManager(new FixedConceptEngine(), reportedDateEngine), null);
using (var sourceData = this._factory.GetReadableDataLocation(new FileInfo(file)))
using (var dataReaderEngine = sdmxDataReaderFactory.GetDataReaderEngine(sourceData, retrievalManager))
{
while (dataReaderEngine.MoveNextDataset())
{
while (dataReaderEngine.MoveNextKeyable())
{
IKeyable currentKey = dataReaderEngine.CurrentKey;
if (currentKey.Series)
{
while (dataReaderEngine.MoveNextObservation())
{
}
}
}
}
}
}
/// <summary>
/// The main.
/// </summary>
/// <param name="args">
/// The args.
/// </param>
public static void Main(string[] args)
{
// 1. initialize the ISdmxObjectRetrievalManager we will use for retrieving Dataflow and DSD.
// Depending on the implementation, they could be retrieved from the registry or mapping store.
// but in this example we used a simple implementation which retrieves them from files.
IStructureParsingManager parsingManager = new StructureParsingManager();
ISdmxObjects objects = new SdmxObjectsImpl();
using (IReadableDataLocation location = new FileReadableDataLocation("ESTAT+STS+2.0.xml"))
{
objects.Merge(parsingManager.ParseStructures(location).GetStructureObjects(false));
}
using (IReadableDataLocation location = new FileReadableDataLocation("ESTAT+SSTSCONS_PROD_M+2.0.xml"))
{
objects.Merge(parsingManager.ParseStructures(location).GetStructureObjects(false));
}
ISdmxObjectRetrievalManager retrievalManager = new InMemoryRetrievalManager(objects);
// 2. initialize the IDataQueryParseManager implementation.
IDataQueryParseManager parseManager = new DataQueryParseManager(SdmxSchemaEnumType.VersionTwo);
// 3. Create a IReadableDataLocation. Since we work with files we use the FileReadableDataLocation implementation.
IList<IDataQuery> buildDataQuery;
using (IReadableDataLocation readable = new FileReadableDataLocation("query.xml"))
{
// 4. we call BuildDataQuery to process the query.xml and get a list of IDataQuery
buildDataQuery = parseManager.BuildDataQuery(readable, retrievalManager);
}
// below we print to console the contents of each IDataQuery
foreach (var dataQuery in buildDataQuery)
{
Console.WriteLine("Dataflow: {0}", dataQuery.Dataflow.Id);
Console.WriteLine("DSD: {0}", dataQuery.DataStructure.Id);
Console.WriteLine("Maximum number of observations (DefaultLimit): {0}", dataQuery.FirstNObservations);
Console.WriteLine("Has selections: {0}", dataQuery.HasSelections());
Console.WriteLine("(");
foreach (var selectionGroup in dataQuery.SelectionGroups)
{
if (selectionGroup.DateFrom != null)
{
Console.WriteLine("\tPeriod from {0}", selectionGroup.DateFrom);
Console.WriteLine(" AND ");
}
if (selectionGroup.DateTo != null)
{
Console.WriteLine("\tPeriod to {0}", selectionGroup.DateTo);
Console.WriteLine(" AND ");
}
foreach (var selection in selectionGroup.Selections)
{
var s = selection.HasMultipleValues ? string.Join(" OR ", selection.Values) : selection.Value;
Console.WriteLine("{0} = ( {1} )", selection.ComponentId, s);
Console.WriteLine(" AND ");
}
}
}
}
private ISdmxObjects LoadSDMXRet(XmlDocument xDomSource)
{
// Converto il documento in un MemoryReadableLocation
MemoryReadableLocation mRL = new MemoryReadableLocation(WSUtils.ConvertToBytes(xDomSource));
IStructureParsingManager _parsingManager = new StructureParsingManager();
// Parse structures IStructureParsingManager is an instance field.
IStructureWorkspace structureWorkspace = _parsingManager.ParseStructures(mRL);
// Get immutable objects from workspace
return structureWorkspace.GetStructureObjects(false);
}
/// <summary>
/// Sends the specified <paramref name="request"/> to the Web Service defined by <see cref="_config"/>
/// </summary>
/// <param name="request">
/// The <see cref="IComplexStructureQuery"/>
/// </param>
/// <returns>
/// The ISdmxObjects returned by the Web Service
/// </returns>
private ISdmxObjects SendQueryStructureRequest(string request)
{
string tempFileName = Path.GetTempFileName();
try
{
this.SendRequest(request, tempFileName, RequestType.Structure);
ISdmxObjects structureObjects = new SdmxObjectsImpl();
IStructureParsingManager parsingManager = new StructureParsingManager(SdmxSchemaEnumType.Null);
using (var dataLocation = new FileReadableDataLocation(tempFileName))
{
IStructureWorkspace structureWorkspace = parsingManager.ParseStructures(dataLocation);
structureObjects = structureWorkspace.GetStructureObjects(false);
}
NsiClientValidation.CheckResponse(structureObjects);
return structureObjects;
}
finally
{
// Delete the temporary file
File.Delete(tempFileName);
}
}
private ISdmxObjects GetSdmxOBJ(string FileName)
{
ISdmxObjects structureObjects = new SdmxObjectsImpl();
IStructureParsingManager parsingManager = new StructureParsingManager(SdmxSchemaEnumType.VersionTwo);
string FullNamePath = Path.Combine(Utils.GetTreeCachePath(), FileName);
if (!File.Exists(FullNamePath))
return null;
using (var dataLocation = new FileReadableDataLocation(FullNamePath))
{
IStructureWorkspace structureWorkspace = parsingManager.ParseStructures(dataLocation);
structureObjects = structureWorkspace.GetStructureObjects(false);
}
return structureObjects;
}
public void TestLikeNSIWCVariousDataWithDsdFile(string file, string dsdFile)
{
IDataReaderManager manager = new DataReaderManager();
ISdmxObjects objects;
using (var dataLocation = this._factory.GetReadableDataLocation(new FileInfo(dsdFile)))
{
IStructureParsingManager parsingManager = new StructureParsingManager();
objects = parsingManager.ParseStructures(dataLocation).GetStructureObjects(false);
}
var retrievalManager = new InMemoryRetrievalManager(objects);
IList<IDictionary<string, string>> dataSetStoreList = new List<IDictionary<string, string>>();
using (var sourceData = this._factory.GetReadableDataLocation(new FileInfo(file)))
using (var compact = manager.GetDataReaderEngine(sourceData, retrievalManager))
{
while (compact.MoveNextKeyable())
{
if (compact.CurrentKey.Series)
{
IList<IKeyValue> keyValues = compact.CurrentKey.Key;
while (compact.MoveNextObservation())
{
var dataSetStore = new Dictionary<string, string>(StringComparer.Ordinal);
foreach (var key in keyValues)
{
dataSetStore.Add(key.Concept, key.Code);
}
IObservation currentObservation = compact.CurrentObservation;
Assert.IsNotNullOrEmpty(currentObservation.ObservationValue);
Assert.IsNotNullOrEmpty(currentObservation.ObsTime);
Assert.IsFalse(currentObservation.CrossSection);
dataSetStore.Add(DimensionObject.TimeDimensionFixedId, currentObservation.ObsTime);
ISdmxDate sdmxDate = new SdmxDateCore(currentObservation.ObsTime);
Assert.NotNull(sdmxDate);
Assert.AreEqual(sdmxDate.TimeFormatOfDate, currentObservation.ObsTimeFormat);
dataSetStore.Add(PrimaryMeasure.FixedId, currentObservation.ObservationValue);
if (!currentObservation.ObservationValue.Equals(EdiConstants.MissingVal))
{
double i;
Assert.IsTrue(double.TryParse(currentObservation.ObservationValue, NumberStyles.Any, CultureInfo.InvariantCulture, out i), "Cannot convert to int {0}", currentObservation.ObservationValue);
}
dataSetStoreList.Add(dataSetStore);
}
}
}
}
}
public void TestRestQueryFormat(string dsd, string dataflow, string query)
{
IStructureParsingManager parsingManager = new StructureParsingManager();
ISdmxObjects objects = new SdmxObjectsImpl();
using (IReadableDataLocation location = new FileReadableDataLocation(dsd))
{
objects.Merge(parsingManager.ParseStructures(location).GetStructureObjects(false));
}
using (IReadableDataLocation location = new FileReadableDataLocation(dataflow))
{
objects.Merge(parsingManager.ParseStructures(location).GetStructureObjects(false));
}
ISdmxObjectRetrievalManager retrievalManager = new InMemoryRetrievalManager(objects);
IList<IDataQuery> buildDataQuery;
IDataQueryParseManager parseManager = new DataQueryParseManager(SdmxSchemaEnumType.VersionTwo);
using (IReadableDataLocation readable = new FileReadableDataLocation(query))
{
// call BuildDataQuery to process the query.xml and get a list of IDataQuery
buildDataQuery = parseManager.BuildDataQuery(readable, retrievalManager);
}
IDataQueryFormat<string> structureQueryFormat = new RestQueryFormat();
IDataQueryFactory dataQueryFactory = new DataQueryFactory();
foreach (var dataQuery in buildDataQuery)
{
IDataQueryBuilderManager dataQueryBuilderManager = new DataQueryBuilderManager(dataQueryFactory);
string request = dataQueryBuilderManager.BuildDataQuery(dataQuery, structureQueryFormat);
Assert.IsNotNull(request);
}
}
public void TestDemoFile(string dataFile, string dsdFIle)
{
IStructureParsingManager manager = new StructureParsingManager();
IDataStructureObject dsd;
using (var dsdLocation = _factory.GetReadableDataLocation(new FileInfo(dsdFIle)))
{
var structureWorkspace = manager.ParseStructures(dsdLocation);
dsd = structureWorkspace.GetStructureObjects(false).DataStructures.First();
}
var fileInfo = new FileInfo(dataFile);
IDataReaderManager parseManager = new DataReaderManager();
var crossDsd = (ICrossSectionalDataStructureObject)dsd;
var mandatoryDataSetAttributes =
crossDsd.GetCrossSectionalAttachDataSet(true, SdmxStructureType.GetFromEnum(SdmxStructureEnumType.DataAttribute))
.Cast<IAttributeObject>()
.Where(o => o.Mandatory)
.ToDictionary(component => component.Id);
using (var dataLocation = _factory.GetReadableDataLocation(fileInfo))
{
var dataReaderEngine = parseManager.GetDataReaderEngine(dataLocation, dsd, null);
int datasetCount = 0;
if (dataReaderEngine.MoveNextDataset())
{
datasetCount++;
_log.DebugFormat("DataSet {0}", dataReaderEngine.DatasetAttributes);
Assert.NotNull(dataReaderEngine.DatasetAttributes);
int keyCount = 0;
while (dataReaderEngine.MoveNextKeyable())
{
keyCount++;
var key = dataReaderEngine.CurrentKey;
_log.DebugFormat("Key {0}", key.Series);
if (key.Series)
{
int obsCount = 0;
while (dataReaderEngine.MoveNextObservation())
{
obsCount++;
var obs = dataReaderEngine.CurrentObservation;
_log.DebugFormat("obs {0}", obs);
Assert.NotNull(obs);
}
Assert.AreEqual(14, obsCount);
}
}
Assert.AreEqual(12, keyCount);
}
Assert.AreEqual(1, datasetCount);
}
}
public ISdmxObjects GetDsd(string DsdId, string DsdAgency, string DsdVersion, bool resolseRef = false)
{
Logger.InfoFormat(
CultureInfo.InvariantCulture,
Resources.InfoGettingStructureFormat3,
DsdAgency,
DsdId,
DsdVersion);
System.Reflection.Assembly ass = System.Reflection.Assembly.GetExecutingAssembly();
string path = System.IO.Path.GetDirectoryName(ass.CodeBase);
string templateFile = Path.Combine(path, "Model\\XMLQueryTemplate\\DOTSTAT_GetDataStructureDefinition.xml");
var doc = new XmlDocument();
doc.Load(templateFile);
var nodesId = doc.GetElementsByTagName("KeyFamily");
if (nodesId == null || nodesId.Count < 1) return null;
nodesId[0].InnerText = DsdId;
var nodeAgency = doc.GetElementsByTagName("Receiver");
if (nodeAgency == null || nodeAgency.Count < 1) return null;
nodeAgency[0].Attributes.GetNamedItem("id").Value = DsdAgency;
string tempFileName = Path.GetTempFileName();
try
{
this.SendRequest(doc, SDMXWSFunction.GetDataStructureDefinition, tempFileName);
XmlDocument xmlDoc = new XmlDocument();
xmlDoc.Load(tempFileName);
var codes = xmlDoc.GetElementsByTagName("Code");
for (int i = 0; i < codes.Count; i++)
{
var val = codes.Item(i).Attributes.GetNamedItem("value");
var par = codes.Item(i).Attributes.GetNamedItem("parentCode");
if (val != null && par != null && val.Value == par.Value)
{
codes.Item(i).Attributes.GetNamedItem("parentCode").Value = null;
}
}
var time_dimensions = xmlDoc.GetElementsByTagName("TimeDimension");
time_dimensions.Item(0).Attributes.RemoveNamedItem("codelist");
xmlDoc.Save(tempFileName);
ISdmxObjects structureObjects = new SdmxObjectsImpl();
IStructureParsingManager parsingManager = new StructureParsingManager(SdmxSchemaEnumType.VersionTwo);
using (var dataLocation = new FileReadableDataLocation(tempFileName))
{
IStructureWorkspace structureWorkspace = parsingManager.ParseStructures(dataLocation);
structureObjects = structureWorkspace.GetStructureObjects(false);
}
NsiClientValidation.CheckResponse(structureObjects);
return structureObjects;
}
finally
{
//delete the temporary file
File.Delete(tempFileName);
}
}
public static IList<ArtefactImportStatus> SubmitStructure(System.IO.Stream stream)
{
System.IO.StreamReader _stream = new System.IO.StreamReader(stream);
ReadableDataLocationFactory fact = new ReadableDataLocationFactory();
IReadableDataLocation rdl = fact.GetReadableDataLocation(_stream.BaseStream);
IList<ArtefactImportStatus> artefactImportStatuses = new List<ArtefactImportStatus>();
try
{
StructureParsingManager spm = new StructureParsingManager();
IStructureWorkspace workspace = spm.ParseStructures(rdl);
ISdmxObjects sdmxObjects = workspace.GetStructureObjects(false);
//sdmxObjects = RemoveNotFinalDSD(sdmxObjects);
var manager = new MappingStoreManager(SQLConnString_DB, artefactImportStatuses);
manager.SaveStructures(sdmxObjects);
_stream.Close();
rdl.Close();
foreach (ArtefactImportStatus datastructure in artefactImportStatuses)
{
if (datastructure.ImportMessage.StructureReference.MaintainableStructureEnumType == Org.Sdmxsource.Sdmx.Api.Constants.SdmxStructureEnumType.Dsd)
{
Delete_Dataflow((int)datastructure.PrimaryKeyValue + 1);
/*
DeleteStructure(new SDMXIdentifier() {
id = datastructure.ImportMessage.StructureReference.MaintainableId,
agencyid = datastructure.ImportMessage.StructureReference.AgencyId,
version = datastructure.ImportMessage.StructureReference.Version,
}, Org.Sdmxsource.Sdmx.Api.Constants.SdmxStructureEnumType.Dataflow); */
}
}
return artefactImportStatuses;
}
catch (Exception ex)
{
_stream.Close();
rdl.Close();
throw ex;
}
}
public void TestCrossSectionalDataWriter(string dsd)
{
ISdmxObjects objects;
var file = new FileInfo(dsd);
IStructureParsingManager manager = new StructureParsingManager(SdmxSchemaEnumType.Null);
using (var readable = new FileReadableDataLocation(file))
{
IStructureWorkspace structureWorkspace = manager.ParseStructures(readable);
objects = structureWorkspace.GetStructureObjects(false);
}
foreach (var dataStructureObject in objects.DataStructures)
{
var crossDsd = dataStructureObject as ICrossSectionalDataStructureObject;
Assert.IsNotNull(crossDsd);
using (var writer = XmlWriter.Create("cross-" + file.Name))
{
var crossWriter = new CrossSectionalWriterEngine(writer, SdmxSchema.GetFromEnum(SdmxSchemaEnumType.VersionTwo));
crossWriter.WriteHeader(new HeaderImpl("TEST", "TEST"));
crossWriter.StartDataset(null, crossDsd, null);
foreach (var component in crossDsd.GetCrossSectionalAttachDataSet(true))
{
switch (component.StructureType.EnumType)
{
case SdmxStructureEnumType.Dimension:
crossWriter.WriteDataSetKeyValue(component.ConceptRef.ChildReference.Id, "DS");
break;
case SdmxStructureEnumType.DataAttribute:
crossWriter.WriteAttributeValue(component.ConceptRef.ChildReference.Id, "DS");
break;
}
}
crossWriter.StartXSGroup();
var timeDimension = crossDsd.GetDimensions(SdmxStructureEnumType.TimeDimension).FirstOrDefault();
IDimension freq = crossDsd.GetDimensions().FirstOrDefault(dimension => dimension.FrequencyDimension);
IAttributeObject timeFormat = crossDsd.Attributes.FirstOrDefault(o => o.TimeFormat);
if (timeDimension != null)
{
crossWriter.WriteXSGroupKeyValue(timeDimension.ConceptRef.ChildReference.Id, "2000");
if (freq != null)
{
crossWriter.WriteXSGroupKeyValue(freq.ConceptRef.ChildReference.Id, "A");
}
if (timeFormat != null)
{
crossWriter.WriteAttributeValue(timeFormat.ConceptRef.ChildReference.Id, "DS");
}
}
foreach (var component in crossDsd.GetCrossSectionalAttachGroup(true))
{
switch (component.StructureType.EnumType)
{
case SdmxStructureEnumType.Dimension:
{
if (!component.Equals(freq))
{
crossWriter.WriteXSGroupKeyValue(component.ConceptRef.ChildReference.Id, "DS");
}
}
break;
case SdmxStructureEnumType.DataAttribute:
if (!component.Equals(timeFormat))
{
crossWriter.WriteAttributeValue(component.ConceptRef.ChildReference.Id, "DS");
}
break;
}
}
crossWriter.StartSection();
foreach (var component in crossDsd.GetCrossSectionalAttachSection(true))
{
switch (component.StructureType.EnumType)
{
case SdmxStructureEnumType.Dimension:
crossWriter.WriteXSGroupKeyValue(component.ConceptRef.ChildReference.Id, "DS");
break;
case SdmxStructureEnumType.DataAttribute:
crossWriter.WriteAttributeValue(component.ConceptRef.ChildReference.Id, "DS");
break;
}
}
if (crossDsd.CrossSectionalMeasures.Count > 0)
{
for (int index = 0; index < crossDsd.CrossSectionalMeasures.Count; index++)
{
var crossSectionalMeasure = crossDsd.CrossSectionalMeasures[index];
crossWriter.StartXSObservation(crossSectionalMeasure.Code, "1.002");
foreach (var component in crossDsd.GetCrossSectionalAttachObservation())
{
switch (component.StructureType.EnumType)
{
case SdmxStructureEnumType.Dimension:
crossWriter.WriteXSGroupKeyValue(component.ConceptRef.ChildReference.Id, "XS" + index);
break;
case SdmxStructureEnumType.DataAttribute:
crossWriter.WriteAttributeValue(component.ConceptRef.ChildReference.Id, "XSOBS");
break;
}
}
}
}
else
{
crossWriter.StartXSObservation(crossDsd.PrimaryMeasure.ConceptRef.ChildReference.Id, "1.002");
foreach (var component in crossDsd.GetCrossSectionalAttachObservation())
{
switch (component.StructureType.EnumType)
{
case SdmxStructureEnumType.Dimension:
crossWriter.WriteXSGroupKeyValue(component.ConceptRef.ChildReference.Id, "PM");
break;
case SdmxStructureEnumType.DataAttribute:
crossWriter.WriteAttributeValue(component.ConceptRef.ChildReference.Id, "PM");
break;
}
}
}
crossWriter.Close();
}
}
}
public void TestBuildComplexDataQueryRaw()
{
IStructureParsingManager manager = new StructureParsingManager();
IDataQueryParseManager queryParseManager = new DataQueryParseManager(SdmxSchemaEnumType.VersionTwoPointOne);
IComplexDataQueryBuilderManager dataQueryBuilderManager = new ComplexDataQueryBuilderManager(new ComplexDataQueryFactoryV21());
IDataflowObject dataFlow;
IDataStructureObject dsd;
using (var readable = new FileReadableDataLocation("tests/V21/Structure/test-sdmxv2.1-ESTAT+SSTSCONS_PROD_M+2.0.xml"))
{
var structureWorkspace = manager.ParseStructures(readable);
dataFlow = structureWorkspace.GetStructureObjects(false).Dataflows.First();
}
using (var readable = new FileReadableDataLocation("tests/V21/Structure/test-sdmxv2.1-ESTAT+STS+2.0.xml"))
{
var structureWorkspace = manager.ParseStructures(readable);
dsd = structureWorkspace.GetStructureObjects(false).DataStructures.First();
}
ISet<IComplexDataQuerySelection> sections = new HashSet<IComplexDataQuerySelection>();
var freqCriteria = new ComplexDataQuerySelectionImpl("FREQ", new IComplexComponentValue [] { new ComplexComponentValueImpl("M", OrderedOperator.GetFromEnum(OrderedOperatorEnumType.Equal), SdmxStructureEnumType.Dimension), new ComplexComponentValueImpl("A", OrderedOperator.GetFromEnum(OrderedOperatorEnumType.NotEqual), SdmxStructureEnumType.Dimension), new ComplexComponentValueImpl("B", OrderedOperator.GetFromEnum(OrderedOperatorEnumType.Equal), SdmxStructureEnumType.Dimension) });
sections.Add(freqCriteria);
var adjustmentCriteria = new ComplexDataQuerySelectionImpl("ADJUSTMENT", new IComplexComponentValue [] { new ComplexComponentValueImpl("01", OrderedOperator.GetFromEnum(OrderedOperatorEnumType.NotEqual), SdmxStructureEnumType.Dimension), new ComplexComponentValueImpl("S2", OrderedOperator.GetFromEnum(OrderedOperatorEnumType.NotEqual), SdmxStructureEnumType.Dimension) });
sections.Add(adjustmentCriteria);
var titleCriteria = new ComplexDataQuerySelectionImpl(
"TITLE",
new IComplexComponentValue [] { new ComplexComponentValueImpl("PAOKARA", TextSearch.GetFromEnum(TextSearchEnumType.Contains), SdmxStructureEnumType.DataAttribute), new ComplexComponentValueImpl("ARIS", TextSearch.GetFromEnum(TextSearchEnumType.DoesNotContain), SdmxStructureEnumType.DataAttribute) });
sections.Add(titleCriteria);
OrderedOperator equalOperator = OrderedOperator.GetFromEnum(OrderedOperatorEnumType.Equal);
var dateFrom = new SdmxDateCore("2000-01");
var dateFromOperator = OrderedOperator.GetFromEnum(OrderedOperatorEnumType.GreaterThanOrEqual);
var primaryMeasureValue = new ComplexComponentValueImpl("200.20", OrderedOperator.GetFromEnum(OrderedOperatorEnumType.GreaterThan), SdmxStructureEnumType.PrimaryMeasure);
ICollection<IComplexDataQuerySelectionGroup> collection = new [] { new ComplexDataQuerySelectionGroupImpl(sections, dateFrom, dateFromOperator, null, equalOperator, new HashSet<IComplexComponentValue> { primaryMeasureValue }) };
var complexDataQueryImpl = new ComplexDataQueryImpl(
null,
null,
null,
dsd,
dataFlow,
null,
null,
0,
null,
false,
null,
DimensionAtObservation.GetFromEnum(DimensionAtObservationEnumType.Time).Value,
false,
DataQueryDetail.GetFromEnum(DataQueryDetailEnumType.Full),
collection);
var buildComplexDataQuery = dataQueryBuilderManager.BuildComplexDataQuery(
complexDataQueryImpl, new StructSpecificDataFormatV21());
var fileName = string.Format("test-TestBuildComplexDataQuery.xml");
buildComplexDataQuery.Save(fileName);
bool insideOr = false;
string localName;
string lastDimension = null;
string value = null;
using (var reader = XmlReader.Create(fileName))
{
while (reader.Read())
{
switch (reader.NodeType)
{
case XmlNodeType.Element:
localName = reader.LocalName;
switch (localName)
{
case "Or":
insideOr = true;
lastDimension = null;
value = null;
break;
}
break;
case XmlNodeType.Text:
value = reader.Value;
break;
case XmlNodeType.EndElement:
if ("ID".Equals(reader.LocalName))
{
if (insideOr)
{
Assert.IsNotNullOrEmpty(value);
if (lastDimension == null)
{
lastDimension = value;
}
Assert.AreEqual(lastDimension, value);
}
}
else if ("Or".Equals(reader.LocalName))
{
insideOr = false;
}
break;
}
}
}
}
/// <summary>
///
/// </summary>
/// <param name="xDomSource"></param>
/// <returns></returns>
private ISdmxObjects LoadSDMXObject(XmlDocument xDomSource)
{
// Il documento template che verrà caricato con gli artefatti da importare
XmlDocument xDomTemp = new XmlDocument();
// Creo gli elementi del file template
xDomTemp.InnerXml = WSConstants.xmlTemplate;
// Il nodo root "Structure" del template
XmlNode xTempStructNode = xDomTemp.SelectSingleNode("//*[local-name()='Structure']");
// Creo il nodo "Structures" che conterrà gli artefatti
XmlNode xSourceStructNode = xDomTemp.CreateNode(XmlNodeType.Element, "Structures", "http://www.sdmx.org/resources/sdmxml/schemas/v2_1/message");
// Inserisco nel nodo "Structures" gli aertefatti presenti nell' sdmx passato in input
xSourceStructNode.InnerXml = xDomSource.SelectSingleNode("//*[local-name()='Structures']").InnerXml;
// Aggiungo al template l'elemento "Structures" con gli artefatti da caricare
xTempStructNode.AppendChild(xSourceStructNode);
// Converto il documento in un MemoryReadableLocation
MemoryReadableLocation mRL = new MemoryReadableLocation(WSUtils.ConvertToBytes(xDomTemp));
IStructureParsingManager _parsingManager = new StructureParsingManager();
// Parse structures IStructureParsingManager is an instance field.
IStructureWorkspace structureWorkspace = _parsingManager.ParseStructures(mRL);
// Get immutable objects from workspace
return structureWorkspace.GetStructureObjects(false);
}
public static IList<ArtefactImportStatus> SubmitStructure(System.IO.Stream stream)
{
System.IO.StreamReader _stream = new System.IO.StreamReader(stream);
ReadableDataLocationFactory fact = new ReadableDataLocationFactory();
IReadableDataLocation rdl = fact.GetReadableDataLocation(_stream.BaseStream);
IList<ArtefactImportStatus> artefactImportStatuses = new List<ArtefactImportStatus>();
try
{
StructureParsingManager spm = new StructureParsingManager();
IStructureWorkspace workspace = spm.ParseStructures(rdl);
ISdmxObjects sdmxObjects = workspace.GetStructureObjects(false);
_stream.Close();
rdl.Close();
return SubmitStructure(sdmxObjects);
}
catch (Exception ex)
{
_stream.Close();
rdl.Close();
throw ex;
}
}
public void TestStructureReaderWriteV2(string file)
{
var structureReader = new StructureReaderV2();
var fileInfo = new FileInfo(file);
IMutableObjects mutableObjects;
XmlReaderSettings settings = XMLParser.GetSdmxXmlReaderSettings(SdmxSchemaEnumType.VersionTwo);
settings.ValidationEventHandler += OnValidationEventHandler;
ISdmxObjects structure;
using (FileStream stream = fileInfo.OpenRead())
{
settings.NameTable = NameTableCache.Instance.NameTable;
using (XmlReader reader = XmlReader.Create(stream, settings))
{
mutableObjects = structureReader.Read(reader);
Assert.NotNull(mutableObjects);
structure = mutableObjects.ImmutableObjects;
Assert.NotNull(structure);
}
}
string output = string.Format(CultureInfo.InvariantCulture, "output-{0}", fileInfo.Name);
using (XmlWriter writer = XmlWriter.Create(output, new XmlWriterSettings { CloseOutput = true, Indent = true }))
{
var structureWriter = new StructureWriterV2(writer);
structureWriter.WriteStructure(mutableObjects, new HeaderImpl("ZZ9", "ZZ9"));
}
using (XmlReader reader = XmlReader.Create(output, settings))
{
IMutableObjects newMutableObjects = structureReader.Read(reader);
Assert.NotNull(newMutableObjects);
ISdmxObjects newStructure = newMutableObjects.ImmutableObjects;
Assert.NotNull(newStructure);
Assert.AreEqual(newStructure.CategorySchemes.Count, structure.CategorySchemes.Count);
Assert.AreEqual(newStructure.Codelists.Count, structure.Codelists.Count);
Assert.AreEqual(newStructure.ConceptSchemes.Count, structure.ConceptSchemes.Count);
Assert.AreEqual(newStructure.Dataflows.Count, structure.Dataflows.Count);
Assert.AreEqual(newStructure.DataStructures.Count, structure.DataStructures.Count);
Assert.AreEqual(newStructure.HierarchicalCodelists.Count, structure.HierarchicalCodelists.Count);
CompareArtefacts(newStructure.CategorySchemes, structure.GetCategorySchemes);
CompareArtefacts(newStructure.Codelists, structure.GetCodelists);
CompareArtefacts(newStructure.ConceptSchemes, structure.GetConceptSchemes);
CompareArtefacts(newStructure.Dataflows, structure.GetDataflows);
CompareArtefacts(newStructure.DataStructures, structure.GetDataStructures);
CompareArtefacts(newStructure.HierarchicalCodelists, structure.GetHierarchicalCodelists);
}
// compare against StructureWorkspace from SdmxStructureParser
var parsingManager = new StructureParsingManager(SdmxSchemaEnumType.VersionTwo);
using (IReadableDataLocation fileReadableDataLocation = new FileReadableDataLocation(file))
{
IStructureWorkspace structureWorkspace = parsingManager.ParseStructures(fileReadableDataLocation);
Assert.NotNull(structureWorkspace);
ISdmxObjects newStructure = structureWorkspace.GetStructureObjects(false);
Assert.NotNull(newStructure);
Assert.AreEqual(newStructure.CategorySchemes.Count, structure.CategorySchemes.Count);
Assert.AreEqual(newStructure.Codelists.Count, structure.Codelists.Count);
Assert.AreEqual(newStructure.ConceptSchemes.Count, structure.ConceptSchemes.Count);
Assert.AreEqual(newStructure.Dataflows.Count, structure.Dataflows.Count);
Assert.AreEqual(newStructure.DataStructures.Count, structure.DataStructures.Count);
Assert.AreEqual(newStructure.HierarchicalCodelists.Count, structure.HierarchicalCodelists.Count);
CompareArtefacts(newStructure.CategorySchemes, structure.GetCategorySchemes);
CompareArtefacts(newStructure.Codelists, structure.GetCodelists);
CompareArtefacts(newStructure.ConceptSchemes, structure.GetConceptSchemes);
CompareArtefacts(newStructure.Dataflows, structure.GetDataflows);
CompareArtefacts(newStructure.DataStructures, structure.GetDataStructures);
CompareArtefacts(newStructure.HierarchicalCodelists, structure.GetHierarchicalCodelists);
}
}
public void TestRiReaderV2(string file)
{
var structureReader = new RegistryInterfaceReaderV2();
var fileInfo = new FileInfo(file);
IRegistryInfo mutableObjects;
XmlReaderSettings settings = XMLParser.GetSdmxXmlReaderSettings(SdmxSchemaEnumType.VersionTwo);
ISdmxObjects structure = null;
using (FileStream stream = fileInfo.OpenRead())
{
settings.NameTable = NameTableCache.Instance.NameTable;
using (XmlReader reader = XmlReader.Create(stream, settings))
{
mutableObjects = structureReader.Read(reader);
Assert.NotNull(mutableObjects);
Assert.IsTrue(mutableObjects.HasQueryStructureRequest || mutableObjects.HasQueryStructureResponse);
if (mutableObjects.HasQueryStructureRequest)
{
CollectionAssert.IsNotEmpty(mutableObjects.QueryStructureRequest.References);
}
else if (mutableObjects.HasQueryStructureResponse)
{
CollectionAssert.IsNotEmpty(mutableObjects.QueryStructureResponse.Structure.AllMaintainables);
structure = mutableObjects.QueryStructureResponse.Structure.ImmutableObjects;
Assert.IsNotNull(structure);
}
}
}
//// mutableObjects.Header = new HeaderImpl("ZZ9", "ZZ9");
string output = string.Format(CultureInfo.InvariantCulture, "output-{0}", fileInfo.Name);
using (XmlWriter writer = XmlWriter.Create(output, new XmlWriterSettings { CloseOutput = true, Indent = true }))
{
var structureWriter = new RegistryInterfaceWriterV2(writer);
structureWriter.WriteRegistryInterface(mutableObjects);
}
using (XmlReader reader = XmlReader.Create(output, settings))
{
mutableObjects = structureReader.Read(reader);
Assert.NotNull(mutableObjects);
Assert.IsTrue(mutableObjects.HasQueryStructureRequest || mutableObjects.HasQueryStructureResponse);
if (mutableObjects.HasQueryStructureRequest)
{
CollectionAssert.IsNotEmpty(mutableObjects.QueryStructureRequest.References);
}
else if (mutableObjects.HasQueryStructureResponse)
{
CollectionAssert.IsNotEmpty(mutableObjects.QueryStructureResponse.Structure.AllMaintainables);
ISdmxObjects newStructure = mutableObjects.QueryStructureResponse.Structure.ImmutableObjects;
Assert.IsNotNull(newStructure);
if (structure != null)
{
Assert.AreEqual(newStructure.CategorySchemes.Count, structure.CategorySchemes.Count);
Assert.AreEqual(newStructure.Codelists.Count, structure.Codelists.Count);
Assert.AreEqual(newStructure.ConceptSchemes.Count, structure.ConceptSchemes.Count);
Assert.AreEqual(newStructure.Dataflows.Count, structure.Dataflows.Count);
Assert.AreEqual(newStructure.DataStructures.Count, structure.DataStructures.Count);
Assert.AreEqual(newStructure.HierarchicalCodelists.Count, structure.HierarchicalCodelists.Count);
CompareArtefacts(newStructure.CategorySchemes, structure.GetCategorySchemes);
CompareArtefacts(newStructure.Codelists, structure.GetCodelists);
CompareArtefacts(newStructure.ConceptSchemes, structure.GetConceptSchemes);
CompareArtefacts(newStructure.Dataflows, structure.GetDataflows);
CompareArtefacts(newStructure.DataStructures, structure.GetDataStructures);
CompareArtefacts(newStructure.HierarchicalCodelists, structure.GetHierarchicalCodelists);
// compare against StructureWorkspace from SdmxStructureParser
var parsingManager = new StructureParsingManager(SdmxSchemaEnumType.VersionTwo);
using (IReadableDataLocation fileReadableDataLocation = new FileReadableDataLocation(file))
{
IStructureWorkspace structureWorkspace = parsingManager.ParseStructures(fileReadableDataLocation);
Assert.NotNull(structureWorkspace);
ISdmxObjects sdmxObjects = structureWorkspace.GetStructureObjects(false);
Assert.NotNull(sdmxObjects);
Assert.AreEqual(sdmxObjects.CategorySchemes.Count, structure.CategorySchemes.Count);
Assert.AreEqual(sdmxObjects.Codelists.Count, structure.Codelists.Count);
Assert.AreEqual(sdmxObjects.ConceptSchemes.Count, structure.ConceptSchemes.Count);
Assert.AreEqual(sdmxObjects.Dataflows.Count, structure.Dataflows.Count);
Assert.AreEqual(sdmxObjects.DataStructures.Count, structure.DataStructures.Count);
Assert.AreEqual(sdmxObjects.HierarchicalCodelists.Count, structure.HierarchicalCodelists.Count);
CompareArtefacts(sdmxObjects.CategorySchemes, structure.GetCategorySchemes);
CompareArtefacts(sdmxObjects.Codelists, structure.GetCodelists);
CompareArtefacts(sdmxObjects.ConceptSchemes, structure.GetConceptSchemes);
CompareArtefacts(sdmxObjects.Dataflows, structure.GetDataflows);
CompareArtefacts(sdmxObjects.DataStructures, structure.GetDataStructures);
CompareArtefacts(sdmxObjects.HierarchicalCodelists, structure.GetHierarchicalCodelists);
}
}
}
}
}
/// <summary>
/// Sends the specified <paramref name="references"/> to the Web Service defined by <see cref="_config"/>
/// </summary>
/// <param name="references">The <see cref="IStructureReference"/></param>
/// <param name="resolveReferences">
/// The resolve references
/// </param>
/// <returns>The QueryStructureResponse returned by the Web Service</returns>
public ISdmxObjects SendQueryStructureRequest(IEnumerable<IStructureReference> references, bool resolveReferences)
{
var queryStructureRequestBuilderManager= new QueryStructureRequestBuilderManager();
IStructureQueryFormat<XDocument> queryFormat = new QueryStructureRequestFormat();
var wdoc = queryStructureRequestBuilderManager.BuildStructureQuery(references, queryFormat, resolveReferences);
var doc = new XmlDocument();
doc.LoadXml(wdoc.ToString());
string tempFileName = Path.GetTempFileName();
try
{
this.SendRequest(doc, SDMXWSFunction.QueryStructure, tempFileName);
ISdmxObjects structureObjects = new SdmxObjectsImpl();
IStructureParsingManager parsingManager = new StructureParsingManager(SdmxSchemaEnumType.Null);
using (var dataLocation = new FileReadableDataLocation(tempFileName))
{
IStructureWorkspace structureWorkspace = parsingManager.ParseStructures(dataLocation);
structureObjects = structureWorkspace.GetStructureObjects(false);
}
NsiClientValidation.CheckResponse(structureObjects);
return structureObjects;
}
finally
{
//delete the temporary file
File.Delete(tempFileName);
}
}
/// <summary>
/// Sends the specified <paramref name="complexStructureQuery"/> to the Web Service defined by <see cref="_config"/>
/// </summary>
/// <param name="complexStructureQuery">The <see cref="IComplexStructureQuery"/></param>
/// <returns>The ISdmxObjects returned by the Web Service</returns>
private ISdmxObjects SendQueryStructureRequest(IComplexStructureQuery complexStructureQuery, SDMXWSFunctionV21 sdmxwsFunctionV21)
{
IStructureQueryFormat<XDocument> queryFormat = new ComplexQueryFormatV21();
IComplexStructureQueryFactory<XDocument> factory = new ComplexStructureQueryFactoryV21<XDocument>();
IComplexStructureQueryBuilderManager<XDocument> complexStructureQueryBuilderManager = new ComplexStructureQueryBuilderManager<XDocument>(factory);
var wdoc = complexStructureQueryBuilderManager.BuildComplexStructureQuery(complexStructureQuery, queryFormat);
var doc = new XmlDocument();
doc.LoadXml(wdoc.ToString());
string tempFileName = Path.GetTempFileName();
try
{
this.SendRequest(doc, sdmxwsFunctionV21, tempFileName);
ISdmxObjects structureObjects = new SdmxObjectsImpl();
IStructureParsingManager parsingManager = new StructureParsingManager(SdmxSchemaEnumType.Null);
using (var dataLocation = new FileReadableDataLocation(tempFileName))
{
IStructureWorkspace structureWorkspace = parsingManager.ParseStructures(dataLocation);
structureObjects = structureWorkspace.GetStructureObjects(false);
}
NsiClientValidation.CheckResponse(structureObjects);
return structureObjects;
}
finally
{
//Delete the temporary file
File.Delete(tempFileName);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="TestInMemoryRetrievalManager"/> class.
/// </summary>
public TestInMemoryRetrievalManager()
{
this._structureParsingManager = new StructureParsingManager();
}
