/// <summary> /// Constructor /// </summary> public WsInfo(NSIClientSettings config, SdmxSchemaEnumType schemaVersion) { _config = config; _schemaVersion = schemaVersion; //endpointType bool endpointTypeOk = Enum.TryParse(_config.EndPointType, true, out _endpointType); if (!endpointTypeOk) { _endpointType = EndpointType.V20; } //endpoint, wsdl if (_schemaVersion == SdmxSchemaEnumType.VersionTwo) { if (_endpointType == EndpointType.V20 && _config.EndPoint != null) { _endpoint = _config.EndPoint; _wsdl = _config.Wsdl; } else { _endpoint = _config.EndPointV20; _wsdl = _config.WsdlV20; } } else { _endpoint = _config.EndPoint; _wsdl = _config.Wsdl; } }
public void ReadingStructures(String structureFile, SdmxSchemaEnumType schema, String output){ // Step 2. Implementing a helper class that parses DSD, Dataflow and writes datasets. //1) Call the method getXmlWriter XmlWriter xmlWriter = this.getXmlWriter(output); //2) Obtain IDataWriterEngine IDataWriterEngine compactWriter = new CompactDataWriterEngine(xmlWriter,SdmxSchema.GetFromEnum(schema)); //3) Read a structure file from a stream this.spm = new StructureParsingManager(); ISdmxObjects structureObjects = new SdmxObjectsImpl(); using (FileStream stream = File.Open(structureFile, FileMode.Open, FileAccess.Read)) { using (IReadableDataLocation rdl = new ReadableDataLocationTmp(stream)) { IStructureWorkspace structureWorkspace = this.spm.ParseStructures(rdl); structureObjects = structureWorkspace.GetStructureObjects(false); } } //4) The IMaintainableRefObject is used to reference structures that extend the IMaintainableObject Interface. IMaintainableRefObject dsdRef = new MaintainableRefObjectImpl("ESTAT", "STS", "2.2"); IMaintainableRefObject flowRef = new MaintainableRefObjectImpl("ESTAT", "SSTSCONS_PROD_A", "1.0"); //5) Get the DataStructure and the Dataflow ISet<IDataStructureObject> dsd = structureObjects.GetDataStructures(dsdRef); ISet<IDataflowObject> dataflow = structureObjects.GetDataflows(flowRef); //6) After obtaining our IDataWriterEngine, and the IDataStructureObject that we wish to create data for, we can write the dataset SampleDataWriter sampleDataWriter = new SampleDataWriter(); sampleDataWriter.writeSampleData(dsd.FirstOrDefault(), dataflow.FirstOrDefault(), compactWriter); xmlWriter.Close(); }
/// <summary> /// Gets the SOAP operation. /// </summary> /// <param name="dataFormat"> /// The data format. /// </param> /// <param name="sdmxSchema"> /// The SDMX schema. /// </param> /// <returns> /// The <see cref="SoapOperation"/>. /// </returns> public static SoapOperation GetSoapOperation(this BaseDataFormat dataFormat, SdmxSchemaEnumType sdmxSchema) { switch (sdmxSchema) { case SdmxSchemaEnumType.Edi: case SdmxSchemaEnumType.Ecv: case SdmxSchemaEnumType.Csv: case SdmxSchemaEnumType.Json: return(SoapOperation.Null); } switch (dataFormat.EnumType) { case BaseDataFormatEnumType.Generic: return(SoapOperation.GetGenericData); case BaseDataFormatEnumType.Compact: return(sdmxSchema == SdmxSchemaEnumType.VersionTwoPointOne ? SoapOperation.GetStructureSpecificData : SoapOperation.GetCompactData); case BaseDataFormatEnumType.Utility: return(sdmxSchema == SdmxSchemaEnumType.VersionTwoPointOne ? SoapOperation.Null : SoapOperation.GetUtilityData); case BaseDataFormatEnumType.CrossSectional: return(sdmxSchema == SdmxSchemaEnumType.VersionTwoPointOne ? SoapOperation.Null : SoapOperation.GetCrossSectionalData); } return(SoapOperation.Null); }
/// <summary> /// Gets the corresponding <see cref="DataType"/> of a <see cref="BaseDataFormat"/> from the specified <paramref name="sdmxSchema"/> /// </summary> /// <param name="dataFormat">The data format.</param> /// <param name="sdmxSchema">The SDMX schema.</param> /// <returns>The <see cref="DataType"/>.</returns> public static DataType GetDataType(this BaseDataFormat dataFormat, SdmxSchemaEnumType sdmxSchema) { if (dataFormat == null) { return null; } return dataFormat.EnumType.GetDataType(sdmxSchema); }
/// <summary> /// Gets the data retrieval with writer. /// </summary> /// <param name="sdmxSchemaVersion"> /// The SDMX schema version. /// </param> /// <returns> /// The <see cref="ISdmxDataRetrievalWithWriter"/>. /// </returns> private ISdmxDataRetrievalWithWriter GetDataRetrievalWithWriter(SdmxSchemaEnumType sdmxSchemaVersion) { switch (sdmxSchemaVersion) { case SdmxSchemaEnumType.VersionTwoPointOne: return(this._retrievalWithWriterv21); default: return(this._retrievalWithWriter); } }
/// <summary> /// Gets the message fault SOAP builder. /// </summary> /// <param name="sdmxSchema">The SDMX schema.</param> /// <returns>The <see cref="IMessageFaultSoapBuilder" />.</returns> public IMessageFaultSoapBuilder GetMessageFaultSoapBuilder(SdmxSchemaEnumType sdmxSchema) { switch (sdmxSchema) { case SdmxSchemaEnumType.VersionTwoPointOne: return this._faultSoapv21Builder; case SdmxSchemaEnumType.VersionTwo: return this._faultSoapv20Builder; } return null; }
/// <summary> /// Builds a success response based on the submitted notifications /// </summary> /// <param name="notifications"> /// - the notifications that were successfully submitted /// </param> /// <param name="schemaVersion"> /// - the version of the schema to output the response in /// </param> /// <returns> /// The <see cref="XTypedElement"/>. /// </returns> public virtual XTypedElement BuildSuccessResponse( ICollection<ISubscriptionObject> notifications, SdmxSchemaEnumType schemaVersion) { switch (schemaVersion) { case SdmxSchemaEnumType.VersionTwoPointOne: return this._v21Builder.BuildSuccessResponse(notifications); default: throw new SdmxNotImplementedException( ExceptionCode.Unsupported, "Submit Subscitpion response in version" + schemaVersion); } }
/// <summary> /// Initializes a new instance of the <see cref="SdmxXmlStream"/> class. /// </summary> /// <param name="reader"> /// The reader. /// </param> /// <param name="messageType"> /// The message type. /// </param> /// <param name="sdmxVersion"> /// The schema enum type. /// </param> /// <param name="registryType"> /// The registry type. /// </param> public SdmxXmlStream(XmlReader reader, MessageEnumType messageType, SdmxSchemaEnumType sdmxVersion, RegistryMessageEnumType registryType) { if (!SdmxSchema.GetFromEnum(sdmxVersion).IsXmlFormat()) { throw new ArgumentException("Input not an SDMX-ML file", "sdmxVersion"); } this._reader = reader; this._messageType = messageType; this._sdmxVersion = sdmxVersion; this._registryType = registryType; }
/// <summary> /// Gets the corresponding <see cref="DataType"/> of a <see cref="BaseDataFormat"/> from the specified <paramref name="sdmxSchema"/> /// </summary> /// <param name="dataFormat">The data format.</param> /// <param name="sdmxSchema">The SDMX schema.</param> /// <returns>The <see cref="DataType"/>.</returns> public static DataType GetDataType(this BaseDataFormatEnumType dataFormat, SdmxSchemaEnumType sdmxSchema) { foreach (var dataType in DataType.Values) { if (dataType.BaseDataFormat.EnumType == dataFormat && dataType.SchemaVersion.EnumType == sdmxSchema) { return dataType; } } return null; }
/// <summary> /// Returns an error response based on the submitted beans and exception /// </summary> /// <param name="subscription"> /// The subscription. /// </param> /// <param name="schemaVersion"> /// - the version of the schema to output the response in /// </param> /// <param name="th"> /// - the error /// </param> /// <returns> /// The <see cref="XTypedElement"/>. /// </returns> public virtual XTypedElement BuildErrorResponse( ISubscriptionObject subscription, SdmxSchemaEnumType schemaVersion, Exception th) { switch (schemaVersion) { case SdmxSchemaEnumType.VersionTwoPointOne: return this._v21Builder.BuildErrorResponse(subscription, th); default: throw new SdmxNotImplementedException( ExceptionCode.Unsupported, "Submit Subscitpion response in version" + schemaVersion); } }
/// <summary> /// Initialie a new instance of the <see cref="RetrievalManager"/> class. /// </summary> /// <param name="_dataFlowID"> /// Dataflow ID /// </param> /// <param name="_versionType">Sdmx Version</param> public RetrievalManager(string _dataFlowID, SdmxSchemaEnumType _versionType) { try { this.DataFlowID = _dataFlowID; this.VersionType = _versionType; DataStructureEngineObject ds = new DataStructureEngineObject(); ISDMXObjectBuilder Builder = ds.CreateBuilder(new SdmxParsingObject(SdmxStructureEnumType.Dataflow) { MaintainableId = DataFlowID, References = StructureReferenceDetailEnumType.Specific, SpecificReference = new List <SdmxStructureType>() { SdmxStructureType.GetFromEnum(SdmxStructureEnumType.Dsd), SdmxStructureType.GetFromEnum(SdmxStructureEnumType.ConceptScheme), }, QueryDetail = StructureQueryDetailEnumType.Full, }, _versionType); Builder.Build(); Builder.AddReferences(); if (Builder._KeyFamily == null || Builder._KeyFamily.Count == 0) { throw new SdmxException(this, FlyExceptionObject.FlyExceptionTypeEnum.InternalError, new Exception(string.Format("Dsd Not found for Dataflow code: {0}", DataFlowID))); } //1DF = 1DSD this._dsd = Builder._KeyFamily[0]; if (Builder._Dataflows.Count > 0) { this.DataFlowTitle = Builder._Dataflows[0].Name; } else { throw new Exception("No Dataflow Found"); } this._sdmxObjects = Builder.CreateDSD(); this.DataFlowID = Builder._Dataflows[0].Id; GetGroups(); } catch (SdmxException) { throw; } catch (Exception ex) { throw new SdmxException(this, FlyExceptionObject.FlyExceptionTypeEnum.InternalError, ex); //non sono riuscito a cambiare il nome che è arrivato dalla query con quello effettivo della dsd } }
/// <summary> /// Build error response for submission of provisions.. /// </summary> /// <param name="exception"> /// The exception. /// </param> /// <param name="structureReference"> /// The structure Reference. /// </param> /// <param name="schemaVersion"> /// The schema version. /// </param> /// <returns> /// The error response for submission of provisions /// </returns> public virtual XTypedElement BuildErrorResponse( Exception exception, IStructureReference structureReference, SdmxSchemaEnumType schemaVersion) { switch (schemaVersion) { case SdmxSchemaEnumType.VersionTwo: return this._submitProvisionResponseBuilderV2.BuildErrorResponse(exception); case SdmxSchemaEnumType.VersionTwoPointOne: return this._v21Builder.BuildErrorResponse(exception, structureReference); default: throw new SdmxNotImplementedException(ExceptionCode.Unsupported, schemaVersion); } }
/// <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> /// Instance of <see cref="IDataMessageManager"/> /// </summary> /// <param name="TimeStamp">LastUpdate parameter request only data from this date onwards</param> /// <param name="_versionTypeResp">Sdmx Version</param> /// <returns></returns> public static IGroupsManager GroupFactory(string TimeStamp, SdmxSchemaEnumType _versionTypeResp) { switch (FlyController.FlyConfiguration.OnTheFlyVersion) { case FlyController.Model.OnTheFlyVersionEnum.OnTheFly1: return(new FlyDotStat_implementation.Manager.Data.GroupsManager(TimeStamp, _versionTypeResp)); case FlyController.Model.OnTheFlyVersionEnum.OnTheFly2: //return new FlySDDSLoader_implementation.Manager.Data.GroupsManager(TimeStamp); return(new FlyDotStat_implementation.Manager.Data.GroupsManager(TimeStamp, _versionTypeResp)); default: throw new SdmxException(typeof(MappingConfiguration), FlyExceptionObject.FlyExceptionTypeEnum.InitConfigError, new Exception("On the Fly Version Error")); } }
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> /// Instance of <see cref="IDataMessageManager"/> /// </summary> /// <param name="VersionTypeResp">Sdmx Version of response</param> /// <returns></returns> public static IDataMessageManager DataFactory(SdmxSchemaEnumType VersionTypeResp) { switch (FlyController.FlyConfiguration.OnTheFlyVersion) { case FlyController.Model.OnTheFlyVersionEnum.OnTheFly1: return(new FlyDotStat_implementation.Manager.Data.DataMessageManager(VersionTypeResp)); case FlyController.Model.OnTheFlyVersionEnum.OnTheFly15: return(new FlyDotStat_implementation.Manager.Data.DataMessageManager(VersionTypeResp)); case FlyController.Model.OnTheFlyVersionEnum.OnTheFly2: return(new FlyDotStat_implementation.Manager.Data.DataMessageManager(VersionTypeResp)); default: throw new SdmxException(typeof(MappingConfiguration), FlyExceptionObject.FlyExceptionTypeEnum.InitConfigError, new Exception("On the Fly Version Error")); } }
/// <summary> /// Returns an error response based on the exception /// </summary> /// <param name="exception"> /// - the error /// </param> /// <param name="schemaVersion"> /// - the version of the schema to output the response in /// </param> /// <returns> /// The <see cref="XTypedElement"/>. /// </returns> public virtual XTypedElement BuildErrorResponse(Exception exception, SdmxSchemaEnumType schemaVersion) { XTypedElement response = null; switch (schemaVersion) { case SdmxSchemaEnumType.VersionTwoPointOne: response = this._errorResponseBuilder21.BuildErrorResponse(exception); break; case SdmxSchemaEnumType.VersionTwo: response = this._queryStructureResponseBuilderV2.BuildErrorResponse(exception); break; default: throw new SdmxNotImplementedException(ExceptionCode.Unsupported, schemaVersion); } base.WriteSchemaLocation(response, schemaVersion); return response; }
/// <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); } }
protected void WriteSchemaLocation(XTypedElement doc, SdmxSchemaEnumType schemaVersion) { if (schemaLocationWriter != null) { List<string> schemaUri = new List<string>(); switch(schemaVersion) { case SdmxSchemaEnumType.VersionOne : schemaUri.Add(SdmxConstants.MessageNs10); break; case SdmxSchemaEnumType.VersionTwo: schemaUri.Add(SdmxConstants.MessageNs20); break; case SdmxSchemaEnumType.VersionTwoPointOne : schemaUri.Add(SdmxConstants.MessageNs21); break; default : throw new SdmxNotImplementedException(ExceptionCode.Unsupported, "Schema Version " + schemaVersion); } schemaLocationWriter.WriteSchemaLocation(doc, schemaUri.ToArray()); } }
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); } }
/// <summary> /// Entrypoint of class FlyEngine that processes the request /// and produces a response or an error /// </summary> /// <param name="_parsingObject">Processed request</param> /// <param name="_versionType">Sdmx Version</param> public void Engine(ISdmxParsingObject _parsingObject, SdmxSchemaEnumType _versionType) { try { this.VersionTypeResp = _versionType; //IDBAccess DbAccess = new DWHAccess(FlyConfiguration.ConnectionString); _parsingObject.PreliminarCheck(); FlyLog.WriteLog(this, FlyLog.LogTypeEnum.All, "Query Preliminar Check passed. Start creation of SDMXObject"); Builder = CreateBuilder(_parsingObject, _versionType); if (Builder == null) { throw new SdmxException(this, FlyExceptionObject.FlyExceptionTypeEnum.NotSupportedRegistryType, new Exception(_parsingObject.SdmxStructureType.ToString())); } FlyLog.WriteLog(this, FlyLog.LogTypeEnum.All, "Parsing Metadata: {0}", _parsingObject.SdmxStructureType.ToString()); Builder.Build(); ParseOtherRegistry(_parsingObject); Builder.AddReferences(); } catch (SdmxException sdmxerr) { HaveError = true; ErrorMessage = sdmxerr; } catch (Exception err) { HaveError = true; ErrorMessage = new SdmxException(this, FlyExceptionObject.FlyExceptionTypeEnum.InternalError, err); } }
/// <summary> /// The process registry query message for provision. /// </summary> /// <param name="reader"> /// The mask 0. /// </param> /// <param name="schemaVersion"> /// The schema version. /// </param> /// <returns> /// The <see cref="IQueryWorkspace"/>. /// </returns> /// <exception cref="SdmxNotImplementedException"> /// Unsupported value at <paramref name="schemaVersion"/> /// </exception> private IQueryWorkspace ProcessRegistryQueryMessageForProvision( XmlReader reader, SdmxSchemaEnumType schemaVersion) { switch (schemaVersion) { case SdmxSchemaEnumType.VersionTwo: RegistryInterface doc = RegistryInterface.Load(reader); IStructureReference provisionReferences = this._queryBuilder.Build(doc.QueryProvisioningRequest); return new QueryWorkspace(provisionReferences, null, null, false); default: throw new SdmxNotImplementedException(ExceptionCode.Unsupported, schemaVersion); } }
/// <summary> /// Processes a query message which is a RegistryInterface Document /// </summary> /// <param name="reader"> /// - the stream containing the SDMX /// </param> /// <param name="schemaVersion"> /// - the schema version that the SDMX is in /// </param> /// <param name="registryMessageType"> /// - the type of query message, provision, registration or structure /// </param> /// <returns> /// The <see cref="IQueryWorkspace"/>. /// </returns> private IQueryWorkspace ProcessRegistryQueryMessage( XmlReader reader, SdmxSchemaEnumType schemaVersion, RegistryMessageEnumType registryMessageType) { switch (registryMessageType) { case RegistryMessageEnumType.QueryProvisionRequest: return this.ProcessRegistryQueryMessageForProvision(reader, schemaVersion); case RegistryMessageEnumType.QueryRegistrationRequest: return this.ProcessRegistryQueryMessageForRegistration(reader, schemaVersion); case RegistryMessageEnumType.QueryStructureRequest: return this.ProcessRegistryQueryMessageForStructures(reader, schemaVersion); default: throw new SdmxNotImplementedException(ExceptionCode.Unsupported, registryMessageType); } }
/// <summary> /// initializes the correct class for the IDsdManager interface /// </summary> /// <param name="_parsingObject">the <see cref="ISdmxParsingObject"/></param> /// <param name="_versionTypeResp">Sdmx Version</param> /// <returns><see cref="IDsdManager"/> Instance</returns> public IDsdManager InstanceDsdManager(ISdmxParsingObject _parsingObject, SdmxSchemaEnumType _versionTypeResp) { return(new DsdManager(_parsingObject, _versionTypeResp)); }
/// <summary> /// initializes the correct class for the ICodelistsManager interface /// </summary> /// <param name="_parsingObject">the <see cref="ISdmxParsingObject"/></param> /// <param name="_versionTypeResp">Sdmx Version</param> /// <returns><see cref="ICodelistManager"/> Instance</returns> public ICodelistManager InstanceCodelistsManager(ISdmxParsingObject _parsingObject, SdmxSchemaEnumType _versionTypeResp) { return(new CodelistManager(_parsingObject, _versionTypeResp)); }
/// <summary> /// Gets the SOAP operation response. /// </summary> /// <param name="dataFormat"> /// The data format. /// </param> /// <param name="sdmxSchema"> /// The SDMX schema. /// </param> /// <returns> /// The SOAP operation response. /// </returns> public static SoapOperationResponse GetSoapOperationResponse(this BaseDataFormat dataFormat, SdmxSchemaEnumType sdmxSchema) { return dataFormat.GetSoapOperation(sdmxSchema).GetResponse(); }
/// <summary> /// Inizialize for BaseManager Class /// </summary> /// <param name="_versionTypeResp">Sdmx Version</param> public DataMessageManager(SdmxSchemaEnumType _versionTypeResp) : base(null, _versionTypeResp) { }
/// <summary> /// Inizialize for BaseManager Class /// </summary> /// <param name="_parsingObject">the <see cref="ISdmxParsingObject"/></param> /// <param name="_versionTypeResp">Sdmx Version</param> public AttributeManager_FromFile(ISdmxParsingObject _parsingObject, SdmxSchemaEnumType _versionTypeResp) : base(_parsingObject, _versionTypeResp) { }
/// <summary> /// Builds a success response along with the query results /// </summary> /// <param name="beans"> /// - the beans that were successfully returned from the query /// </param> /// <param name="schemaVersion"> /// - the version of the schema to output the response in /// </param> /// <param name="returnAsStructureMessage"> /// returns a structure message if true, otherwise returns as a query structure response /// </param> /// <returns> /// The <see cref="XTypedElement"/>. /// </returns> public virtual XTypedElement BuildSuccessResponse( ISdmxObjects beans, SdmxSchemaEnumType schemaVersion, bool returnAsStructureMessage) { XTypedElement response = null; switch (schemaVersion) { case SdmxSchemaEnumType.VersionTwoPointOne: if (beans.GetAllMaintainables().Count == 0) { response = this._errorResponseBuilder21.BuildErrorResponse(SdmxErrorCodeEnumType.NoResultsFound); } response = this._structV21Builder.Build(beans); break; case SdmxSchemaEnumType.VersionTwo: if (returnAsStructureMessage) { response = this._structv2Builder.Build(beans); } response = this._queryStructureResponseBuilderV2.BuildSuccessResponse(beans); break; case SdmxSchemaEnumType.VersionOne: response = this._structv1Builder.Build(beans); break; default: throw new SdmxNotImplementedException(ExceptionCode.Unsupported, schemaVersion); } base.WriteSchemaLocation(response, schemaVersion); return response; }
/// <summary> /// Initializes a new instance of the <see cref="DataRetrievalInfo" /> class. /// </summary> /// <param name="mappingSet">The mapping set of the dataflow found in the SDMX query</param> /// <param name="query">The current SDMX Query object</param> /// <param name="connectionStringSettings">The Mapping Store connection string settings</param> /// <param name="schemaVersion">The schema version.</param> /// <exception cref="System.ArgumentNullException"> /// mappingSet /// or /// connectionStringSettings /// </exception> public DataRetrievalInfo(MappingSetEntity mappingSet, IDataQuery query, ConnectionStringSettings connectionStringSettings, SdmxSchemaEnumType schemaVersion) { if (mappingSet == null) { throw new ArgumentNullException("mappingSet"); } if (connectionStringSettings == null) { throw new ArgumentNullException("connectionStringSettings"); } this._mappingSet = mappingSet; this._query = query; this._connectionStringSettings = connectionStringSettings; this._schemaVersion = schemaVersion; if (schemaVersion == SdmxSchemaEnumType.VersionTwoPointOne) { this._isTimePeriodAtObservation = DimensionObject.TimeDimensionFixedId.Equals(query.DimensionAtObservation); if (!this._isTimePeriodAtObservation) { this._dimensionAtObservation = query.DimensionAtObservation; } this._limit = 0; // REST does not support default limit. } else { this._limit = query.FirstNObservations.HasValue ? query.FirstNObservations.Value : 0; this._isTimePeriodAtObservation = true; } this.BuildMappings(); this._buildEffectiveDimensionAtObservation = this.BuildEffectiveDimensionAtObservation(); }
/// <summary> /// Create CodelistBuilder Istance /// </summary> /// <param name="parsingObject">Parsing Object <see cref="ISdmxParsingObject"/></param> /// <param name="versionTypeResp">Sdmx Version</param> public CodelistBuilder(ISdmxParsingObject parsingObject, SdmxSchemaEnumType versionTypeResp) : base(parsingObject, versionTypeResp) { }
/// <summary> /// create a GetCodelists instance /// </summary> /// <param name="_parsingObject">Sdmx Parsing Object</param> /// <param name="_versionTypeResp">Sdmx Version</param> public GetCodelists(ISdmxParsingObject _parsingObject, SdmxSchemaEnumType _versionTypeResp) : base(_parsingObject, _versionTypeResp) { }
/// <summary> /// initializes the correct class for the ICategoriesManager interface /// </summary> /// <param name="_parsingObject">the <see cref="ISdmxParsingObject"/></param> /// <param name="_versionTypeResp">Sdmx Version</param> /// <returns><see cref="ICategoriesManager"/> Instance</returns> public ICategoriesManager InstanceCategoriesManager(ISdmxParsingObject _parsingObject, SdmxSchemaEnumType _versionTypeResp) { //if (string.IsNullOrEmpty(FlyConfiguration.ConnectionStringCategory)) // return new FlyDotStat_implementation.Manager.Metadata.CategoriesManagerSP(_parsingObject, _versionTypeResp); //else // return new FlyDotStat_implementation.Manager.Metadata.CategoriesManager(_parsingObject, _versionTypeResp); return(new CategoriesManager(_parsingObject, _versionTypeResp)); }
/// <summary> /// The process registry query message for registration. /// </summary> /// <param name="reader"> /// The mask 0. /// </param> /// <param name="schemaVersion"> /// The schema version. /// </param> /// <returns> /// The <see cref="IQueryWorkspace"/>. /// </returns> /// <exception cref="SdmxNotImplementedException"> /// Unsupported value at <paramref name="schemaVersion"/> /// </exception> private IQueryWorkspace ProcessRegistryQueryMessageForRegistration( XmlReader reader, SdmxSchemaEnumType schemaVersion) { IStructureReference registrationReferences; switch (schemaVersion) { case SdmxSchemaEnumType.VersionTwo: RegistryInterface doc = RegistryInterface.Load(reader); registrationReferences = this._queryBuilder.Build(doc.QueryRegistrationRequest); break; case SdmxSchemaEnumType.VersionTwoPointOne: Org.Sdmx.Resources.SdmxMl.Schemas.V21.Message.RegistryInterface doc21 = Org.Sdmx.Resources.SdmxMl.Schemas.V21.Message.RegistryInterface.Load(reader); registrationReferences = this._queryBuilder.Build(doc21.Content.QueryRegistrationRequest); break; default: throw new SdmxNotImplementedException(ExceptionCode.Unsupported, schemaVersion); } return new QueryWorkspace(null, registrationReferences, null, false); }
/// <summary> /// Inizialize new instance of CategorySchemeBuilder /// </summary> /// <param name="parsingObject">Parsing Object <see cref="ISdmxParsingObject"/></param> /// <param name="versionTypeResp">Sdmx Version</param> public CategorySchemeBuilder(ISdmxParsingObject parsingObject, SdmxSchemaEnumType versionTypeResp) : base(parsingObject, versionTypeResp) { }
/// <summary> /// The process registry query message for structures. /// </summary> /// <param name="reader"> /// The mask 0. /// </param> /// <param name="schemaVersion"> /// The schema version. /// </param> /// <returns> /// The <see cref="IQueryWorkspace"/>. /// </returns> /// <exception cref="SdmxNotImplementedException"> /// Unsupported value at <paramref name="schemaVersion"/> /// </exception> private IQueryWorkspace ProcessRegistryQueryMessageForStructures( XmlReader reader, SdmxSchemaEnumType schemaVersion) { switch (schemaVersion) { case SdmxSchemaEnumType.VersionTwo: RegistryInterface doc = RegistryInterface.Load(reader); IList<IStructureReference> structureReferences = this._queryBuilder.Build(doc.QueryStructureRequest); bool resolveRefernces = doc.QueryStructureRequest.resolveReferences; return new QueryWorkspace(null, null, structureReferences, resolveRefernces); default: throw new SdmxNotImplementedException(ExceptionCode.Unsupported, schemaVersion); } }
/// <summary> /// initializes the correct class for the IAgencyManager interface /// </summary> /// <param name="_parsingObject">the <see cref="ISdmxParsingObject"/></param> /// <param name="_versionTypeResp">Sdmx Version</param> /// <returns><see cref="IAgencyManager"/> Instance</returns> public IAgencyManager InstanceAgencyManager(ISdmxParsingObject _parsingObject, SdmxSchemaEnumType _versionTypeResp) { return(new FlyDotStat_implementation.Manager.Metadata.AgencyManager(_parsingObject, _versionTypeResp)); }
/// <summary> /// Gets the SOAP operation. /// </summary> /// <param name="dataFormat"> /// The data format. /// </param> /// <param name="sdmxSchema"> /// The SDMX schema. /// </param> /// <returns> /// The <see cref="SoapOperation"/>. /// </returns> public static SoapOperation GetSoapOperation(this BaseDataFormat dataFormat, SdmxSchemaEnumType sdmxSchema) { switch (sdmxSchema) { case SdmxSchemaEnumType.Edi: case SdmxSchemaEnumType.Ecv: case SdmxSchemaEnumType.Csv: case SdmxSchemaEnumType.Json: return SoapOperation.Null; } switch (dataFormat.EnumType) { case BaseDataFormatEnumType.Generic: return SoapOperation.GetGenericData; case BaseDataFormatEnumType.Compact: return sdmxSchema == SdmxSchemaEnumType.VersionTwoPointOne ? SoapOperation.GetStructureSpecificData : SoapOperation.GetCompactData; case BaseDataFormatEnumType.Utility: return sdmxSchema == SdmxSchemaEnumType.VersionTwoPointOne ? SoapOperation.Null : SoapOperation.GetUtilityData; case BaseDataFormatEnumType.CrossSectional: return sdmxSchema == SdmxSchemaEnumType.VersionTwoPointOne ? SoapOperation.Null : SoapOperation.GetCrossSectionalData; } return SoapOperation.Null; }
/// <summary> /// initializes the correct class for the IConceptSchemeManager interface /// </summary> /// <param name="_parsingObject">the <see cref="ISdmxParsingObject"/></param> /// <param name="_versionTypeResp">Sdmx Version</param> /// <returns><see cref="IConceptSchemeManager"/> Instance</returns> public IConceptSchemeManager InstanceConceptSchemeManager(ISdmxParsingObject _parsingObject, SdmxSchemaEnumType _versionTypeResp) { IConceptSchemeManager csManager = new ConceptSchemeManager(_parsingObject, _versionTypeResp); return(csManager); }
/// <summary> /// Initializes a new instance of the <see cref="DataRetrieverCore" /> class. Constructor for building a new DataRetriever object. /// </summary> /// <param name="defaultHeader">The default header to use for dataflows without header</param> /// <param name="connectionStringSettings">The connection to the "Mapping Store", from which the "Mapping Set" will be retrieved</param> /// <param name="sdmxSchemaVersion">The SDMX schema version. /// This controls the behavior of <see cref="ISdmxDataRetrievalWithWriter"/> when no results are found. If set to <see cref="SdmxSchemaEnumType.VersionTwoPointOne"/> DR will throw a <see cref="SdmxNoResultsException"/>. Otherwise a empty dataset will be written. This affects only <see cref="ISdmxDataRetrievalWithWriter"/> behavior. <see cref="IAdvancedSdmxDataRetrievalWithWriter"/> will always throw an exception. /// While <see cref="ISdmxDataRetrievalWithCrossWriter"/> and <see cref="IDataRetrieverTabular"/> will never throw an exception for no results.</param> /// <exception cref="System.ArgumentNullException">connectionStringSettings is null</exception> /// <exception cref="System.ArgumentNullException">defaultHeader is null</exception> public DsplDataRetrieverCore(IHeader defaultHeader, ConnectionStringSettings connectionStringSettings, SdmxSchemaEnumType sdmxSchemaVersion) : this(defaultHeader, connectionStringSettings) { this._sdmxSchemaVersion = sdmxSchemaVersion; }
/// <summary> /// Inizialize for BaseManager Class /// </summary> /// <param name="_parsingObject">the <see cref="ISdmxParsingObject"/></param> /// <param name="_versionTypeResp">Sdmx Version</param> public ConceptSchemeManager(ISdmxParsingObject _parsingObject, SdmxSchemaEnumType _versionTypeResp) : base(_parsingObject, _versionTypeResp) { }
/// <summary> /// Implement correct Metadata Builder to process the request /// identifies the correct implementation with the SdmxStructureType property of SdmxParsingObject /// </summary> /// <param name="_parsingObject">Processed request</param> /// <param name="_versionTypeResp">Sdmx Version</param> /// <returns>Implementation of SDMXObjectBuilder</returns> public ISDMXObjectBuilder CreateBuilder(ISdmxParsingObject _parsingObject, SdmxSchemaEnumType _versionTypeResp) { try { this.VersionTypeResp = _versionTypeResp; ISDMXObjectBuilder _builder = null; EngineChooser chooser = new EngineChooser(_parsingObject, _versionTypeResp); #region Creazione dei Builder switch (_parsingObject.SdmxStructureType) { case Org.Sdmxsource.Sdmx.Api.Constants.SdmxStructureEnumType.Dataflow: _builder = chooser.GetDataflows(); break; case Org.Sdmxsource.Sdmx.Api.Constants.SdmxStructureEnumType.ConceptScheme: _builder = chooser.GetConcepts(); break; case Org.Sdmxsource.Sdmx.Api.Constants.SdmxStructureEnumType.CodeList: _builder = chooser.GetCodelists(); break; case Org.Sdmxsource.Sdmx.Api.Constants.SdmxStructureEnumType.AgencyScheme: case Org.Sdmxsource.Sdmx.Api.Constants.SdmxStructureEnumType.OrganisationScheme: _builder = chooser.GetAgencyScheme(); break; case Org.Sdmxsource.Sdmx.Api.Constants.SdmxStructureEnumType.CategoryScheme: case Org.Sdmxsource.Sdmx.Api.Constants.SdmxStructureEnumType.Categorisation: _builder = chooser.GetCategoryScheme(); break; case Org.Sdmxsource.Sdmx.Api.Constants.SdmxStructureEnumType.Dsd: _builder = chooser.GetStructure(); break; //qui sotto ancora non implementate case Org.Sdmxsource.Sdmx.Api.Constants.SdmxStructureEnumType.Annotation: case Org.Sdmxsource.Sdmx.Api.Constants.SdmxStructureEnumType.Any: case Org.Sdmxsource.Sdmx.Api.Constants.SdmxStructureEnumType.AttachmentConstraint: case Org.Sdmxsource.Sdmx.Api.Constants.SdmxStructureEnumType.AttachmentConstraintAttachment: case Org.Sdmxsource.Sdmx.Api.Constants.SdmxStructureEnumType.AttributeDescriptor: case Org.Sdmxsource.Sdmx.Api.Constants.SdmxStructureEnumType.CategoryId: case Org.Sdmxsource.Sdmx.Api.Constants.SdmxStructureEnumType.CategoryMap: case Org.Sdmxsource.Sdmx.Api.Constants.SdmxStructureEnumType.CategorySchemeMap: case Org.Sdmxsource.Sdmx.Api.Constants.SdmxStructureEnumType.Code: case Org.Sdmxsource.Sdmx.Api.Constants.SdmxStructureEnumType.CodeListMap: case Org.Sdmxsource.Sdmx.Api.Constants.SdmxStructureEnumType.CodeListRef: case Org.Sdmxsource.Sdmx.Api.Constants.SdmxStructureEnumType.CodeMap: case Org.Sdmxsource.Sdmx.Api.Constants.SdmxStructureEnumType.Component: case Org.Sdmxsource.Sdmx.Api.Constants.SdmxStructureEnumType.ComponentMap: case Org.Sdmxsource.Sdmx.Api.Constants.SdmxStructureEnumType.Computation: case Org.Sdmxsource.Sdmx.Api.Constants.SdmxStructureEnumType.ConceptMap: case Org.Sdmxsource.Sdmx.Api.Constants.SdmxStructureEnumType.ConceptSchemeMap: case Org.Sdmxsource.Sdmx.Api.Constants.SdmxStructureEnumType.ConstrainedDataKey: case Org.Sdmxsource.Sdmx.Api.Constants.SdmxStructureEnumType.ConstrainedDataKeyset: case Org.Sdmxsource.Sdmx.Api.Constants.SdmxStructureEnumType.Constraint: case Org.Sdmxsource.Sdmx.Api.Constants.SdmxStructureEnumType.ConstraintContentTarget: case Org.Sdmxsource.Sdmx.Api.Constants.SdmxStructureEnumType.Contact: case Org.Sdmxsource.Sdmx.Api.Constants.SdmxStructureEnumType.ContentConstraint: case Org.Sdmxsource.Sdmx.Api.Constants.SdmxStructureEnumType.ContentConstraintAttachment: case Org.Sdmxsource.Sdmx.Api.Constants.SdmxStructureEnumType.CrossSectionalMeasure: case Org.Sdmxsource.Sdmx.Api.Constants.SdmxStructureEnumType.CubeRegion: case Org.Sdmxsource.Sdmx.Api.Constants.SdmxStructureEnumType.DataAttribute: case Org.Sdmxsource.Sdmx.Api.Constants.SdmxStructureEnumType.DataConsumer: case Org.Sdmxsource.Sdmx.Api.Constants.SdmxStructureEnumType.DataConsumerScheme: case Org.Sdmxsource.Sdmx.Api.Constants.SdmxStructureEnumType.DataProvider: case Org.Sdmxsource.Sdmx.Api.Constants.SdmxStructureEnumType.DataProviderScheme: case Org.Sdmxsource.Sdmx.Api.Constants.SdmxStructureEnumType.Dataset: case Org.Sdmxsource.Sdmx.Api.Constants.SdmxStructureEnumType.DatasetReference: case Org.Sdmxsource.Sdmx.Api.Constants.SdmxStructureEnumType.DatasetTarget: case Org.Sdmxsource.Sdmx.Api.Constants.SdmxStructureEnumType.Datasource: case Org.Sdmxsource.Sdmx.Api.Constants.SdmxStructureEnumType.Dimension: case Org.Sdmxsource.Sdmx.Api.Constants.SdmxStructureEnumType.DimensionDescriptor: case Org.Sdmxsource.Sdmx.Api.Constants.SdmxStructureEnumType.DimensionDescriptorValuesTarget: case Org.Sdmxsource.Sdmx.Api.Constants.SdmxStructureEnumType.Group: case Org.Sdmxsource.Sdmx.Api.Constants.SdmxStructureEnumType.HierarchicalCode: case Org.Sdmxsource.Sdmx.Api.Constants.SdmxStructureEnumType.HierarchicalCodelist: case Org.Sdmxsource.Sdmx.Api.Constants.SdmxStructureEnumType.Hierarchy: case Org.Sdmxsource.Sdmx.Api.Constants.SdmxStructureEnumType.HybridCode: case Org.Sdmxsource.Sdmx.Api.Constants.SdmxStructureEnumType.HybridCodelistMap: case Org.Sdmxsource.Sdmx.Api.Constants.SdmxStructureEnumType.IdentifiableObjectTarget: case Org.Sdmxsource.Sdmx.Api.Constants.SdmxStructureEnumType.InputOutput: case Org.Sdmxsource.Sdmx.Api.Constants.SdmxStructureEnumType.ItemMap: case Org.Sdmxsource.Sdmx.Api.Constants.SdmxStructureEnumType.KeyValues: case Org.Sdmxsource.Sdmx.Api.Constants.SdmxStructureEnumType.Level: case Org.Sdmxsource.Sdmx.Api.Constants.SdmxStructureEnumType.LocalRepresentation: case Org.Sdmxsource.Sdmx.Api.Constants.SdmxStructureEnumType.MeasureDescriptor: case Org.Sdmxsource.Sdmx.Api.Constants.SdmxStructureEnumType.MeasureDimension: case Org.Sdmxsource.Sdmx.Api.Constants.SdmxStructureEnumType.MetadataAttribute: case Org.Sdmxsource.Sdmx.Api.Constants.SdmxStructureEnumType.MetadataDocument: case Org.Sdmxsource.Sdmx.Api.Constants.SdmxStructureEnumType.MetadataFlow: case Org.Sdmxsource.Sdmx.Api.Constants.SdmxStructureEnumType.MetadataReferenceValue: case Org.Sdmxsource.Sdmx.Api.Constants.SdmxStructureEnumType.MetadataReport: case Org.Sdmxsource.Sdmx.Api.Constants.SdmxStructureEnumType.MetadataReportAttribute: case Org.Sdmxsource.Sdmx.Api.Constants.SdmxStructureEnumType.MetadataReportTarget: case Org.Sdmxsource.Sdmx.Api.Constants.SdmxStructureEnumType.MetadataSet: case Org.Sdmxsource.Sdmx.Api.Constants.SdmxStructureEnumType.MetadataTarget: case Org.Sdmxsource.Sdmx.Api.Constants.SdmxStructureEnumType.MetadataTargetRegion: case Org.Sdmxsource.Sdmx.Api.Constants.SdmxStructureEnumType.Msd: case Org.Sdmxsource.Sdmx.Api.Constants.SdmxStructureEnumType.Null: case Org.Sdmxsource.Sdmx.Api.Constants.SdmxStructureEnumType.OrganisationMap: case Org.Sdmxsource.Sdmx.Api.Constants.SdmxStructureEnumType.OrganisationSchemeMap: case Org.Sdmxsource.Sdmx.Api.Constants.SdmxStructureEnumType.OrganisationUnit: case Org.Sdmxsource.Sdmx.Api.Constants.SdmxStructureEnumType.OrganisationUnitScheme: case Org.Sdmxsource.Sdmx.Api.Constants.SdmxStructureEnumType.PrimaryMeasure: case Org.Sdmxsource.Sdmx.Api.Constants.SdmxStructureEnumType.Process: case Org.Sdmxsource.Sdmx.Api.Constants.SdmxStructureEnumType.ProcessStep: case Org.Sdmxsource.Sdmx.Api.Constants.SdmxStructureEnumType.ProvisionAgreement: case Org.Sdmxsource.Sdmx.Api.Constants.SdmxStructureEnumType.ReferencePeriod: case Org.Sdmxsource.Sdmx.Api.Constants.SdmxStructureEnumType.Registration: case Org.Sdmxsource.Sdmx.Api.Constants.SdmxStructureEnumType.RelatedStructures: case Org.Sdmxsource.Sdmx.Api.Constants.SdmxStructureEnumType.ReleaseCalendar: case Org.Sdmxsource.Sdmx.Api.Constants.SdmxStructureEnumType.ReportPeriodTarget: case Org.Sdmxsource.Sdmx.Api.Constants.SdmxStructureEnumType.ReportStructure: case Org.Sdmxsource.Sdmx.Api.Constants.SdmxStructureEnumType.ReportingCategory: case Org.Sdmxsource.Sdmx.Api.Constants.SdmxStructureEnumType.ReportingTaxonomy: case Org.Sdmxsource.Sdmx.Api.Constants.SdmxStructureEnumType.ReportingTaxonomyMap: case Org.Sdmxsource.Sdmx.Api.Constants.SdmxStructureEnumType.RepresentationMap: case Org.Sdmxsource.Sdmx.Api.Constants.SdmxStructureEnumType.StructureMap: case Org.Sdmxsource.Sdmx.Api.Constants.SdmxStructureEnumType.StructureSet: case Org.Sdmxsource.Sdmx.Api.Constants.SdmxStructureEnumType.Subscription: case Org.Sdmxsource.Sdmx.Api.Constants.SdmxStructureEnumType.TextFormat: case Org.Sdmxsource.Sdmx.Api.Constants.SdmxStructureEnumType.TextType: case Org.Sdmxsource.Sdmx.Api.Constants.SdmxStructureEnumType.TimeDimension: case Org.Sdmxsource.Sdmx.Api.Constants.SdmxStructureEnumType.TimeRange: case Org.Sdmxsource.Sdmx.Api.Constants.SdmxStructureEnumType.Transition: default: break; } #endregion return(_builder); } catch (SdmxException) { throw; } catch (Exception ex) { throw new SdmxException(this, FlyExceptionObject.FlyExceptionTypeEnum.CreateBuilder, ex); } }
/// <summary> /// Inizialize for BaseManager Class /// </summary> /// <param name="_parsingObject">the <see cref="ISdmxParsingObject"/></param> /// <param name="_versionTypeResp">Sdmx Version</param> public BaseManager(ISdmxParsingObject _parsingObject, SdmxSchemaEnumType _versionTypeResp) { this.parsingObject = _parsingObject; this.versionTypeResp = _versionTypeResp; }
/// <summary> /// Inizialize for BaseManager Class /// </summary> /// <param name="_parsingObject">the <see cref="ISdmxParsingObject"/></param> /// <param name="_versionTypeResp">Sdmx Version</param> public DimensionCodelistsManager(ISdmxParsingObject _parsingObject, SdmxSchemaEnumType _versionTypeResp) : base(_parsingObject, _versionTypeResp) { }
/// <summary> /// Builds a submit registration response, /// then the error will be documented, and a status of failure will be put against it. /// </summary> /// <param name="exception"> /// The exception. /// </param> /// <param name="schemaVersion"> /// The SDMX Schema version /// </param> /// <returns> /// The <see cref="XTypedElement"/>. /// </returns> public virtual XTypedElement BuildErrorResponse(Exception exception, SdmxSchemaEnumType schemaVersion) { // FUNC ERROR CODE? // TODO use a constant for 1000 return this._errorResponseBuilder.BuildErrorResponse(exception, "1000"); }
/// <summary> /// Initializes a new instance of the <see cref="BaseParsingManager"/> class. /// </summary> /// <param name="sdmxSchema"> /// The sdmx schema. /// </param> protected BaseParsingManager(SdmxSchemaEnumType sdmxSchema) : this(sdmxSchema, MessageEnumType.Null) { }
/// <summary> /// create a GetAgencyScheme instance /// </summary> /// <param name="_parsingObject">Sdmx Parsing Object</param> /// <param name="_versionTypeResp">Sdmx Version</param> public GetAgencyScheme(ISdmxParsingObject _parsingObject, SdmxSchemaEnumType _versionTypeResp) : base(_parsingObject, _versionTypeResp) { }
/// <summary> /// Inizialize for BaseManager Class /// </summary> /// <param name="_parsingObject">the <see cref="ISdmxParsingObject"/></param> /// <param name="_versionTypeResp">Sdmx Version</param> public DataflowsManager(ISdmxParsingObject _parsingObject, SdmxSchemaEnumType _versionTypeResp) : base(_parsingObject, _versionTypeResp) { }
/// <summary> /// create a SDMXObjectBuilder instance /// and requires all Classbuilder to request this information /// </summary> /// <param name="_parsingObject">Processed request</param> /// <param name="_versionTypeResp">Sdmx Version</param> public SDMXObjectBuilder(ISdmxParsingObject _parsingObject, SdmxSchemaEnumType _versionTypeResp) { this.ParsingObject = _parsingObject; this.VersionTypeResp = _versionTypeResp; }
/// <summary> /// Initializes a new instance of the <see cref="DataRetrievalInfo"/> class. /// </summary> /// <param name="mappingSet"> /// The mapping set of the dataflow found in the SDMX query /// </param> /// <param name="query"> /// The current SDMX Query object /// </param> /// <param name="connectionStringSettings"> /// The Mapping Store connection string settings /// </param> public DataRetrievalInfo(MappingSetEntity mappingSet, IComplexDataQuery query, ConnectionStringSettings connectionStringSettings) { if (mappingSet == null) { throw new ArgumentNullException("mappingSet"); } if (connectionStringSettings == null) { throw new ArgumentNullException("connectionStringSettings"); } this._schemaVersion = SdmxSchemaEnumType.VersionTwoPointOne; this._mappingSet = mappingSet; this._complexQuery = query; this._connectionStringSettings = connectionStringSettings; this._limit = query.DefaultLimit.HasValue ? query.DefaultLimit.Value : 0; this._isTimePeriodAtObservation = DimensionObject.TimeDimensionFixedId.Equals(query.DimensionAtObservation); if (!this._isTimePeriodAtObservation) { this._dimensionAtObservation = query.DimensionAtObservation; } this.BuildMappings(); this._buildEffectiveDimensionAtObservation = this.BuildEffectiveDimensionAtObservation(); }
/// <summary> /// Gets the SOAP operation. /// </summary> /// <param name="structureOutputFormat"> /// The structure output format. /// </param> /// <param name="sdmxSchema"> /// The SDMX schema. /// </param> /// <param name="structure"> /// Type of the structure requested. (Only in SDMX v2.1 ). /// </param> /// <returns> /// The <see cref="SoapOperation"/>. /// </returns> public static SoapOperation GetSoapOperation(this StructureOutputFormatEnumType structureOutputFormat, SdmxSchemaEnumType sdmxSchema, SdmxStructureEnumType structure) { switch (structureOutputFormat) { case StructureOutputFormatEnumType.Null: break; case StructureOutputFormatEnumType.SdmxV1StructureDocument: break; case StructureOutputFormatEnumType.SdmxV2StructureDocument: break; case StructureOutputFormatEnumType.SdmxV2RegistrySubmitDocument: break; case StructureOutputFormatEnumType.SdmxV2RegistryQueryResponseDocument: return(SoapOperation.QueryStructure); case StructureOutputFormatEnumType.SdmxV21StructureDocument: switch (structure) { case SdmxStructureEnumType.Constraint: return(SoapOperation.GetConstraint); case SdmxStructureEnumType.OrganisationScheme: return(SoapOperation.GetOrganisationScheme); case SdmxStructureEnumType.StructureSet: return(SoapOperation.GetStructureSet); case SdmxStructureEnumType.Dataflow: return(SoapOperation.GetDataflow); case SdmxStructureEnumType.CodeList: return(SoapOperation.GetCodelist); case SdmxStructureEnumType.Categorisation: return(SoapOperation.GetCategorisation); case SdmxStructureEnumType.CategoryScheme: return(SoapOperation.GetCategoryScheme); case SdmxStructureEnumType.ConceptScheme: return(SoapOperation.GetConceptScheme); case SdmxStructureEnumType.Dsd: return(SoapOperation.GetDataStructure); case SdmxStructureEnumType.HierarchicalCodelist: return(SoapOperation.GetHierarchicalCodelist); default: return(SoapOperation.GetStructures); } case StructureOutputFormatEnumType.SdmxV21RegistrySubmitDocument: break; case StructureOutputFormatEnumType.SdmxV21QueryResponseDocument: break; case StructureOutputFormatEnumType.Edi: break; case StructureOutputFormatEnumType.Csv: break; default: return(SoapOperation.Null); } return(SoapOperation.Null); }
/// <summary> /// Initializes a new instance of the <see cref="DataRetrievalInfoSeries" /> class. /// </summary> /// <param name="mappingSet">The mapping set of the dataflow found in the sdmx query</param> /// <param name="query">The current SDMX Query object</param> /// <param name="connectionStringSettings">The Mapping Store connection string settings</param> /// <param name="seriesWriter">The series Writer.</param> /// <param name="sdmxSchemaVersion">The SDMX schema version.</param> public DataRetrievalInfoSeries(MappingSetEntity mappingSet, IDataQuery query, ConnectionStringSettings connectionStringSettings, IDataWriterEngine seriesWriter, SdmxSchemaEnumType sdmxSchemaVersion) : base(mappingSet, query, connectionStringSettings, sdmxSchemaVersion) { this._seriesWriter = seriesWriter; this._seriesObsComponents = new List<IComponentMapping>(); this._dataSetAttributes = new List<IComponentMapping>(); this._groups = new Dictionary<GroupEntity, GroupInformation>(); this._useDataSetSqlQuery = mappingSet.Dataflow.Dsd.Groups.Count > 0; this.BuildSeriesMappings(); // add dimension mappings to groups this.BuildTimeSeriesGroupMappings(); }
/// <summary> /// Gets the SOAP operation response. /// </summary> /// <param name="dataFormat"> /// The data format. /// </param> /// <param name="sdmxSchema"> /// The SDMX schema. /// </param> /// <returns> /// The SOAP operation response. /// </returns> public static SoapOperationResponse GetSoapOperationResponse(this BaseDataFormat dataFormat, SdmxSchemaEnumType sdmxSchema) { return(dataFormat.GetSoapOperation(sdmxSchema).GetResponse()); }
/// <summary> /// Builds a submit registration response, if there is an exception against the Registration /// then the error will be documented, and a status of failure will be put against it. /// </summary> /// <param name="responses"> /// The responses /// </param> /// <param name="schemaVersion"> /// The SDMX Schema version /// </param> /// <returns> /// The <see cref="XTypedElement"/>. /// </returns> public virtual XTypedElement BuildResponse( IDictionary<IRegistrationObject, Exception> responses, SdmxSchemaEnumType schemaVersion) { switch (schemaVersion) { case SdmxSchemaEnumType.VersionTwo: return this._submitRegistrationResponseBuilderV2.BuildResponse(responses); case SdmxSchemaEnumType.VersionTwoPointOne: return this._submitRegistrationResponseBuilderV21.BuildResponse(responses); default: throw new SdmxNotImplementedException(ExceptionCode.Unsupported, schemaVersion); } }
/// <summary> /// Inizialize for BaseManager Class /// </summary> /// <param name="_parsingObject">the <see cref="ISdmxParsingObject"/></param> /// <param name="_versionTypeResp">Sdmx Version</param> public BaseCategoriesManager(ISdmxParsingObject _parsingObject, SdmxSchemaEnumType _versionTypeResp) : base(_parsingObject, _versionTypeResp) { }
/// <summary> /// Initializes a new instance of the <see cref="BaseParsingManager"/> class. /// </summary> /// <param name="sdmxSchema"> /// The sdmx schema. /// </param> /// <param name="messageType"> /// The message Type. /// </param> protected BaseParsingManager(SdmxSchemaEnumType sdmxSchema, MessageEnumType messageType) { this._sdmxSchema = sdmxSchema; this._messageType = messageType; }
/// <summary> /// initializes the correct class for the ICategoriesManager interface /// </summary> /// <param name="_parsingObject">the <see cref="ISdmxParsingObject"/></param> /// <param name="_versionTypeResp">Sdmx Version</param> /// <returns><see cref="ICategoriesManager"/> Instance</returns> public ICategoriesManager InstanceCategoriesManager(ISdmxParsingObject _parsingObject, SdmxSchemaEnumType _versionTypeResp) { if (string.IsNullOrEmpty(FlyConfiguration.ConnectionStringCategory)) { return(new CategoriesManagerSP(_parsingObject, _versionTypeResp)); } else { return(new CategoriesManager(_parsingObject, _versionTypeResp)); } }
/// <summary> /// Instance of EngineChooser <see cref="EngineChooser"/> /// </summary> /// <param name="_parsingObject">Processed request</param> /// <param name="_versionTypeResp">Sdmx Version</param> public EngineChooser(ISdmxParsingObject _parsingObject, SdmxSchemaEnumType _versionTypeResp) { this._parsingObject = _parsingObject; this._versionTypeResp = _versionTypeResp; }
/// <summary> /// initializes the correct class for the IDataflowsManager interface /// </summary> /// <param name="_parsingObject">the <see cref="ISdmxParsingObject"/></param> /// <param name="_versionTypeResp">Sdmx Version</param> /// <returns><see cref="IDataflowsManager"/> Instance</returns> public IDataflowsManager InstanceDataflowsManager(ISdmxParsingObject _parsingObject, SdmxSchemaEnumType _versionTypeResp) { IDataflowsManager dfManager = new DatasetsManager(_parsingObject, _versionTypeResp); if (dfManager.DbAccess.CheckExistStoreProcedure(DBOperationEnum.GetDataflows)) { return(new DataflowsManager(_parsingObject, _versionTypeResp)); } return(dfManager); }