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