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