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); } }