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);
}
}
/// <summary>
/// The main.
/// </summary>
/// <param name="args">
/// The args.
/// </param>
public static void Main(string[] args)
{
IQueryParsingManager manager = new QueryParsingManager(SdmxSchemaEnumType.VersionTwo);
IQueryWorkspace workspace;
using (IReadableDataLocation location = new FileReadableDataLocation("QueryStructureRequest.xml"))
{
workspace = manager.ParseQueries(location);
}
if (workspace != null)
{
Console.WriteLine("Is Resolve references : {0}", workspace.ResolveReferences);
Console.WriteLine("Has Structure Queries : {0}", workspace.HasStructureQueries());
if (workspace.HasStructureQueries())
{
foreach (IStructureReference simpleStructureQuery in workspace.SimpleStructureQueries)
{
IMaintainableRefObject reference = simpleStructureQuery.MaintainableReference;
Console.WriteLine(
"Requested a {0}\n\tAgency ID: {1}\n\tId: {2}\n\tVersion: {3}",
simpleStructureQuery.MaintainableStructureEnumType,
reference.HasAgencyId() ? reference.AgencyId : "(none)",
reference.HasMaintainableId() ? reference.MaintainableId : "(none)",
reference.HasVersion() ? reference.Version : "(none)");
}
}
}
}
public void Test(string file, bool expectedResult)
{
using (var reader = new FileReadableDataLocation(file))
{
Assert.AreEqual(expectedResult, XmlUtil.IsXML(reader));
}
}
public void Test(string file)
{
using (var readable = new FileReadableDataLocation(file))
{
Assert.IsTrue(readable.InputStream.ReadByte() > 0);
Assert.AreNotSame(readable.InputStream, readable.InputStream);
}
}
public void TestXSOutput(string filePath)
{
IList<IDataQuery> dataQueries;
using (IReadableDataLocation dataLocation = new FileReadableDataLocation(filePath))
{
dataQueries = this._dataQueryParseManager.BuildDataQuery(dataLocation, this._retrievalManager);
}
Assert.IsNotEmpty(dataQueries);
var dataQuery = dataQueries.First();
var outputFileName = string.Format("{0}-out.xml", filePath);
using (XmlWriter writer = XmlWriter.Create(outputFileName))
{
var dataWriter = new CrossSectionalWriterEngine(writer, SdmxSchema.GetFromEnum(SdmxSchemaEnumType.VersionTwo));
this._dataRetrieval.GetData(dataQuery, dataWriter);
writer.Flush();
}
var fileInfo = new FileInfo(outputFileName);
Assert.IsTrue(fileInfo.Exists);
var dsd = dataQuery.DataStructure as ICrossSectionalDataStructureObject;
Assert.NotNull(dsd);
using (var fileStream = fileInfo.OpenRead())
using (var reader = XmlReader.Create(fileStream))
{
while (reader.Read())
{
switch (reader.NodeType)
{
case XmlNodeType.Element:
{
var localName = reader.LocalName;
switch (localName)
{
case "DataSet":
AssertDimensionsAreMapped(dsd.GetCrossSectionalAttachDataSet(true, SdmxStructureType.GetFromEnum(SdmxStructureEnumType.Dimension)), reader);
break;
case "Section":
AssertDimensionsAreMapped(dsd.GetCrossSectionalAttachSection(true, SdmxStructureType.GetFromEnum(SdmxStructureEnumType.Dimension)), reader);
break;
case "Group":
AssertDimensionsAreMapped(dsd.GetCrossSectionalAttachGroup(true, SdmxStructureType.GetFromEnum(SdmxStructureEnumType.Dimension)), reader);
break;
case "OBS_VALUE":
AssertDimensionsAreMapped(dsd.GetCrossSectionalAttachObservation(SdmxStructureType.GetFromEnum(SdmxStructureEnumType.Dimension)), reader);
break;
}
}
break;
}
}
}
}
public void TestParseQueries(string testFile)
{
var manager = new CustomQueryParseManager(SdmxSchemaEnumType.VersionTwo);
using (var readable = new FileReadableDataLocation(testFile))
{
var result = manager.ParseQueries(readable);
Assert.IsNotEmpty(result.SimpleStructureQueries);
}
}
public void TestQueryParserManagerV20(string file)
{
using (var fileReadableDataLocation = new FileReadableDataLocation(file))
{
IQueryParsingManager queryParsingManager = new QueryParsingManager(SdmxSchemaEnumType.VersionTwo);
IQueryWorkspace queryWorkspace = queryParsingManager.ParseQueries(fileReadableDataLocation);
Assert.IsNotNull(queryWorkspace);
Assert.IsNotEmpty(queryWorkspace.SimpleStructureQueries);
}
}
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 TestSDMXv20(string queryFile)
{
IDataQuery query;
using (IReadableDataLocation dataLocation = new FileReadableDataLocation(queryFile))
{
query = this._dataQueryParseManager.BuildDataQuery(dataLocation, this._retrievalManager).First();
}
var outputFileName = string.Format("{0}-out.xml", queryFile);
using (XmlWriter writer = XmlWriter.Create(outputFileName, new XmlWriterSettings() {Indent = true}))
{
var compactWriter = new CompactDataWriterEngine(writer, SdmxSchema.GetFromEnum(SdmxSchemaEnumType.VersionTwo));
this._dataRetrievalRest.GetData(query, compactWriter);
}
var selectionGroup = query.SelectionGroups.First();
var fileInfo = new FileInfo(outputFileName);
Assert.IsTrue(fileInfo.Exists);
using (var fileStream = fileInfo.OpenRead())
using (var reader = XmlReader.Create(fileStream))
{
TimeFormat freqValue = TimeFormat.GetFromEnum(TimeFormatEnumType.Null);
while (reader.Read())
{
switch (reader.NodeType)
{
case XmlNodeType.Element:
{
var localName = reader.LocalName;
if (localName.Equals("Series"))
{
Assert.IsTrue(reader.HasAttributes);
freqValue = TimeFormat.GetTimeFormatFromCodeId(reader.GetAttribute("FREQ"));
}
else if (localName.Equals("Obs"))
{
Assert.NotNull(freqValue);
Assert.IsTrue(reader.HasAttributes);
var dateStr = reader.GetAttribute(DimensionObject.TimeDimensionFixedId);
ISdmxDate date = new SdmxDateCore(dateStr);
var dateFrom = new SdmxDateCore(new SdmxDateCore(selectionGroup.DateFrom.Date, freqValue).DateInSdmxFormat);
var dateTo = new SdmxDateCore(new SdmxDateCore(selectionGroup.DateTo.Date, freqValue).DateInSdmxFormat);
Assert.GreaterOrEqual(date.Date, dateFrom.Date);
Assert.LessOrEqual(date.Date, dateTo.Date);
}
}
break;
}
}
}
}
public void TestParseSdmxFooterMessage(string fileName, string code, Severity severity, string firstText)
{
using (IReadableDataLocation dataLocation = new FileReadableDataLocation(fileName))
{
var sdmxFooterMessage = SdmxMessageUtilExt.ParseSdmxFooterMessage(dataLocation);
Assert.IsNotNull(sdmxFooterMessage);
Assert.AreEqual(sdmxFooterMessage.Code, code);
Assert.AreEqual(sdmxFooterMessage.Severity, severity);
Assert.IsNotEmpty(sdmxFooterMessage.FooterText);
Assert.AreEqual(firstText, sdmxFooterMessage.FooterText.First().Value);
}
}
public void TestReadableDataLocationCtor(string file)
{
using (var readable = new FileReadableDataLocation(file))
{
using (var sdmxXmlStream = new SdmxXmlStream(readable))
{
Assert.IsTrue(sdmxXmlStream.HasReader);
Assert.IsNotNull(sdmxXmlStream.Reader);
Assert.AreEqual(MessageEnumType.Structure, sdmxXmlStream.MessageType);
Assert.AreEqual(SdmxSchemaEnumType.VersionTwo, sdmxXmlStream.SdmxVersion);
Assert.AreEqual(RegistryMessageEnumType.Null, sdmxXmlStream.RegistryType);
}
}
}
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);
}
}
}
public void TestBuildStructureQuery(string testFile)
{
var manager = new CustomQueryParseManager(SdmxSchemaEnumType.VersionTwo);
IQueryWorkspace result;
using (var readable = new FileReadableDataLocation(testFile))
{
result = manager.ParseQueries(readable);
}
var builderManager = new QueryStructureRequestBuilderManager(new HeaderImpl("TEST", "TEST"));
var document = builderManager.BuildStructureQuery(result.SimpleStructureQueries, new QueryStructureRequestFormat(), result.ResolveReferences);
Assert.NotNull(document);
}
public void readStructures(String structureFile, SdmxSchemaEnumType schema) {
IReadableDataLocation rdl = new FileReadableDataLocation(structureFile);
spm = new StructureParsingManager(SdmxSchemaEnumType.VersionTwoPointOne);
IStructureWorkspace workspace = spm.ParseStructures(rdl);
ISdmxObjects sdmxObjects = workspace.GetStructureObjects(false);
ISet<IMaintainableObject> maintainables = sdmxObjects.GetAllMaintainables();
foreach (IMaintainableObject m in maintainables) {
Console.WriteLine(m.Urn);
Console.WriteLine(m.StructureType.StructureType + " - " + m.Name);
Console.WriteLine(" --- ");
}
}
/// <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();
}
}
public void TestParseQueriesCustom(string testFile)
{
var manager = new CustomQueryParseManager(SdmxSchemaEnumType.VersionTwo);
using (var readable = new FileReadableDataLocation(testFile))
{
var result = manager.ParseQueries(readable);
Assert.IsNotEmpty(result.SimpleStructureQueries);
foreach (var reference in result.SimpleStructureQueries)
{
if (reference.MaintainableStructureEnumType.EnumType == SdmxStructureEnumType.Dataflow)
{
var constrainable = reference as ConstrainableStructureReference;
Assert.NotNull(constrainable);
Assert.NotNull(constrainable.ConstraintObject);
}
}
}
}
/// <summary>
/// The read structure workspace.
/// </summary>
/// <param name="file">
/// The file.
/// </param>
/// <param name="test">
/// The test.
/// </param>
protected static void ReadStructureMutable(string file, Action<ISdmxObjects> test)
{
IStructureParsingManager parsingManager = new StructureMutableParsingManager();
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);
}
}
public void TestNestedAndOr(string queryFile, string dataflowFile, string dsdFile, string name)
{
var retrievalManager = this.GetSdmxObjectRetrievalManager(dataflowFile, dsdFile);
var connectionString = ConfigurationManager.ConnectionStrings [name];
ISdmxDataRetrievalWithWriter dr = new DataRetrieverCore(new HeaderImpl("TestNestedAndOr", "ZZ9"), connectionString, SdmxSchemaEnumType.VersionTwo);
IList<IDataQuery> dataQuery;
using (var fileReadableDataLocation = new FileReadableDataLocation(queryFile))
{
dataQuery = this.dataQueryParseManager.BuildDataQuery(fileReadableDataLocation, retrievalManager);
Assert.IsNotEmpty(dataQuery);
}
var outputFileName = string.Format("{0}-TestNestedAndOr-out.xml", queryFile);
using (XmlWriter writer = XmlWriter.Create(outputFileName, new XmlWriterSettings { Indent = true }))
using (IDataWriterEngine dataWriter = new CompactDataWriterEngine(writer, SdmxSchema.GetFromEnum(SdmxSchemaEnumType.VersionTwo)))
{
dr.GetData(dataQuery.First(), dataWriter);
}
}
/// <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();
}
}
public void TestBuildSuccessResponse(SdmxSchemaEnumType version)
{
var responseBuilder = new SubmitStructureResponseBuilder();
ISdmxObjects sdmxObjects = new SdmxObjectsImpl();
var codelist = new CodelistMutableCore() { Id = "CL_TEST", Version = "1.0", AgencyId = "TEST" };
codelist.AddName("en", "Test Codelist");
for (int i = 0; i < 10; i++)
{
ICodeMutableObject item = new CodeMutableCore() { Id = "TEST_" + i.ToString(CultureInfo.InvariantCulture) };
item.AddName("en", "Name for " + item.Id);
codelist.AddItem(item);
}
sdmxObjects.AddCodelist(codelist.ImmutableInstance);
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);
}
}
public void TestDetail(SdmxStructureEnumType sdmxStructure, StructureReferenceDetailEnumType detail)
{
var agency = new ComplexTextReferenceCore(null, TextSearch.GetFromEnum(TextSearchEnumType.Equal), "TEST");
var id = new ComplexTextReferenceCore(null, TextSearch.GetFromEnum(TextSearchEnumType.Equal), "TEST");
IComplexVersionReference versionRef = new ComplexVersionReferenceCore(TertiaryBool.ParseBoolean(false), "1.0", null, null);
var complexStructureReferenceCore = new ComplexStructureReferenceCore(agency, id, versionRef, SdmxStructureType.GetFromEnum(sdmxStructure), null, null, null, null);
var complexStructureQueryMetadataCore = new ComplexStructureQueryMetadataCore(
true,
ComplexStructureQueryDetail.GetFromEnum(ComplexStructureQueryDetailEnumType.Full),
ComplexMaintainableQueryDetail.GetFromEnum(ComplexMaintainableQueryDetailEnumType.Full),
StructureReferenceDetail.GetFromEnum(detail),
new [] { SdmxStructureType.GetFromEnum(sdmxStructure) });
IComplexStructureQuery complexStructureQuery = new ComplexStructureQueryCore(complexStructureReferenceCore, complexStructureQueryMetadataCore);
var builder = new ComplexStructureQueryBuilderV21();
var structureQuery = builder.BuildComplexStructureQuery(complexStructureQuery);
var fileName = string.Format("test-ComplexStructureQueryBuilderV21-{0}-{1}.xml", sdmxStructure.ToString(), detail.ToString());
structureQuery.Save(fileName);
using (var readable = new FileReadableDataLocation(fileName))
{
XMLParser.ValidateXml(readable, SdmxSchemaEnumType.VersionTwoPointOne);
}
}
/// <summary>
/// Validates the document.
/// </summary>
/// <param name="outInfo">The out information.</param>
/// <param name="document">The document.</param>
private static void ValidateDocument(FileInfo outInfo, XDocument document)
{
using (var stream = outInfo.Create())
{
document.Save(stream);
stream.Flush();
}
using (var readableLocation = new FileReadableDataLocation(outInfo))
{
XMLParser.ValidateXml(readableLocation, SdmxSchemaEnumType.VersionTwoPointOne);
}
}
/// <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 ");
}
}
}
}
/// <summary>
/// Invokes the service.
/// </summary>
/// <param name="wsClient">
/// The ws client.
/// </param>
/// <param name="operation">
/// The operation.
/// </param>
/// <param name="request">
/// The request.
/// </param>
/// <param name="response">
/// The response.
/// </param>
/// <param name="schemaVersion">
/// The schema version.
/// </param>
/// <param name="compress">
/// if set to <c>true</c> [compress].
/// </param>
/// <returns>
/// The <see cref="bool"/>.
/// </returns>
public bool InvokeService(SdmxWsClient wsClient, SoapOperation operation, FileInfo request, FileInfo response, SdmxSchemaEnumType schemaVersion, bool compress = false)
{
var sdmxMessage = new FileInfo(Path.Combine(response.DirectoryName ?? string.Empty, response.Name + ".sdmx.xml"));
try
{
wsClient.InvokeService(operation, request, response, compress);
using (var reader = XmlReader.Create(response.FullName, new XmlReaderSettings() {IgnoreWhitespace = true, IgnoreComments = true, IgnoreProcessingInstructions = true}))
using (var writer = XmlWriter.Create(sdmxMessage.FullName, new XmlWriterSettings() {Encoding = Encoding.UTF8, Indent = true }))
{
SdmxMessageUtil.FindSdmx(reader);
writer.WriteNode(reader, true);
writer.Flush();
}
}
catch (WebException e)
{
_log.Error(e.Message, e);
var webResponse = e.Response;
if (webResponse != null)
{
var tempFileName = Path.GetTempFileName();
_log.ErrorFormat("Logging error at {0}", tempFileName);
WriteResponse(webResponse, tempFileName);
var errorCode = GetErrorCode(tempFileName);
_log.ErrorFormat("Error code : {0} ", errorCode);
_log.Error(File.ReadAllText(tempFileName));
File.Delete(tempFileName);
}
throw;
}
using (IReadableDataLocation location = new FileReadableDataLocation(sdmxMessage))
{
var actualVersion = SdmxMessageUtil.GetSchemaVersion(location);
if (actualVersion != schemaVersion)
{
return false;
}
var actualMessageType = SdmxMessageUtil.GetMessageType(location);
var expectedMessageType = operation.GetMessageType();
if (actualMessageType != expectedMessageType)
{
return false;
}
}
return true;
}
/// <summary>
/// Gets the error code.
/// </summary>
/// <param name="tempFileName">
/// Name of the temporary file.
/// </param>
/// <returns>
/// The <see cref="string"/>.
/// </returns>
private static string GetErrorCode(string tempFileName)
{
string errorCode = null;
using (IReadableDataLocation location = new FileReadableDataLocation(tempFileName))
{
if (XmlUtil.IsXML(location))
{
using (XmlReader reader = XmlReader.Create(location.InputStream))
{
string localName = null;
while (reader.Read())
{
switch (reader.NodeType)
{
case XmlNodeType.Element:
localName = reader.LocalName;
break;
case XmlNodeType.EndElement:
localName = null;
break;
case XmlNodeType.Text:
if ("ErrorNumber".Equals(localName))
{
return reader.Value;
}
break;
}
}
}
}
}
return errorCode;
}
/// <summary>
/// The main.
/// </summary>
/// <param name="args">
/// The args.
/// </param>
public static void Main(string[] args)
{
// 1. We need a IDataStructureObject. In this example we read it from a file. Alternative we could build it from a mutable object.
IDataStructureObject dataStructure;
using (IReadableDataLocation readable = new FileReadableDataLocation("ESTAT+STS+2.0.xml"))
{
IStructureWorkspace structureWorkspace = _parsingManager.ParseStructures(readable);
ISdmxObjects structureObjects = structureWorkspace.GetStructureObjects(false);
dataStructure = structureObjects.DataStructures.FirstOrDefault();
}
if (dataStructure == null)
{
throw new InvalidOperationException("Could not build dataStructure object");
}
using (var writer = File.CreateText("re-using-gesmes-writer.ges"))
{
IDataWriterEngine dataWriterEngine = new GesmesTimeSeriesWriter(writer, true);
// write header
dataWriterEngine.WriteHeader(new HeaderImpl("ZZ9", "ZZ9"));
// start dataset
dataWriterEngine.StartDataset(null, dataStructure, null);
// write dataset attributes
dataWriterEngine.WriteAttributeValue("TITLE", "GESMES test");
// write 2 group entries
dataWriterEngine.StartGroup("SIBLING");
dataWriterEngine.WriteGroupKeyValue("REF_AREA", "EL");
dataWriterEngine.WriteGroupKeyValue("STS_INDICATOR", "PROD");
dataWriterEngine.WriteGroupKeyValue("STS_ACTIVITY", "NS0030");
dataWriterEngine.WriteGroupKeyValue("STS_INSTITUTION", "1");
dataWriterEngine.WriteGroupKeyValue("ADJUSTMENT", "N");
dataWriterEngine.WriteAttributeValue("COMPILATION", "test");
dataWriterEngine.StartGroup("SIBLING");
dataWriterEngine.WriteGroupKeyValue("REF_AREA", "EL");
dataWriterEngine.WriteGroupKeyValue("STS_INDICATOR", "IND");
dataWriterEngine.WriteGroupKeyValue("STS_ACTIVITY", "NS0030");
dataWriterEngine.WriteGroupKeyValue("STS_INSTITUTION", "1");
dataWriterEngine.WriteGroupKeyValue("ADJUSTMENT", "N");
dataWriterEngine.WriteAttributeValue("COMPILATION", "test2");
// write a series entry
dataWriterEngine.StartSeries();
dataWriterEngine.WriteSeriesKeyValue("FREQ", "A");
dataWriterEngine.WriteSeriesKeyValue("REF_AREA", "EL");
dataWriterEngine.WriteSeriesKeyValue("STS_INDICATOR", "PROD");
dataWriterEngine.WriteGroupKeyValue("STS_ACTIVITY", "NS0030");
dataWriterEngine.WriteGroupKeyValue("STS_INSTITUTION", "1");
dataWriterEngine.WriteGroupKeyValue("ADJUSTMENT", "N");
// write 2 observations for the abose series
dataWriterEngine.WriteObservation("2001", "1.23");
dataWriterEngine.WriteAttributeValue("OBS_STATUS", "A");
dataWriterEngine.WriteAttributeValue("OBS_CONF", "F");
dataWriterEngine.WriteObservation("2002", "4.56");
dataWriterEngine.WriteAttributeValue("OBS_STATUS", "A");
dataWriterEngine.WriteAttributeValue("OBS_CONF", "F");
// write another series entry
dataWriterEngine.StartSeries();
dataWriterEngine.WriteSeriesKeyValue("FREQ", "A");
dataWriterEngine.WriteSeriesKeyValue("REF_AREA", "EL");
dataWriterEngine.WriteSeriesKeyValue("STS_INDICATOR", "IND");
dataWriterEngine.WriteGroupKeyValue("STS_ACTIVITY", "NS0030");
dataWriterEngine.WriteGroupKeyValue("STS_INSTITUTION", "1");
dataWriterEngine.WriteGroupKeyValue("ADJUSTMENT", "N");
// write 1 observation for the abose series
dataWriterEngine.WriteObservation("2001", "7.89");
dataWriterEngine.WriteAttributeValue("OBS_STATUS", "A");
dataWriterEngine.WriteAttributeValue("OBS_CONF", "F");
// close compact Writer
dataWriterEngine.Close();
}
}
/// <summary>
/// Execute SDMX Query against the NSI WS to retrieve SDMX-ML Data as a Stream
/// </summary>
/// <param name="query">
/// The SDMX Query to execute
/// </param>
/// <param name="operationName">
/// The type of operation, GetCompactData or GetCrossSectionalData
/// </param>
/// <param name="tempFileName">
/// The temporary file name
/// </param>
/// <exception cref="NsiClientException">
/// Failute to execute query
/// </exception>
public void ExecuteQuery(IDataQuery query, SDMXWSFunction operationName, string tempFileName)
{
if (query == null)
{
throw new ArgumentNullException("query");
}
try
{
switch (operationName)
{
case SDMXWSFunction.GetCompactData:
{
this.SendSdmxQuery(query, tempFileName);
using (var dataLocation = new FileReadableDataLocation(tempFileName))
{
var sdmxFooterMessage = SdmxMessageUtilExt.ParseSdmxFooterMessage(dataLocation);
if (sdmxFooterMessage!=null && (sdmxFooterMessage.Code.Equals("510") || sdmxFooterMessage.Code.Equals("130")))
{
var sb = new StringBuilder();
foreach (var footerText in sdmxFooterMessage.FooterText)
{
sb.Append(footerText.Value + " ");
}
string info = string.Format(CultureInfo.InvariantCulture, Resources.SdmxFooterMessage, sb, sdmxFooterMessage.Code, sdmxFooterMessage.Severity);
Logger.ErrorFormat(CultureInfo.InvariantCulture, Resources.MaxObservations, info);
throw new FooterMessageException(Resources.EnterMoreCriteria);
}
}
break;
}
case SDMXWSFunction.GetCrossSectionalData:
{
this._nsiClientWs.ExecuteQuery(query, operationName, tempFileName);
break;
}
default:
{
Logger.Error(Resources.ExceptionExecuteQuery);
throw new NsiClientException(Resources.ExceptionExecuteQuery);
}
}
}
catch (NsiClientException e)
{
Logger.Error(Resources.ExceptionExecuteQuery);
NsiClientHelper.TryToDelete(tempFileName);
Logger.Error(e.Message, e);
throw;
}
catch (DataflowException e)
{
throw;
}
catch (FooterMessageException e)
{
NsiClientHelper.TryToDelete(tempFileName);
throw;
}
catch (Exception e)
{
Logger.Error(Resources.ExceptionExecuteQuery);
NsiClientHelper.TryToDelete(tempFileName);
throw new NsiClientException(Resources.ExceptionExecuteQuery, e);
}
}
/// <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);
}
}
