/// <summary>
/// Validates the SDMX V20.
/// </summary>
/// <param name="dataQuery">
/// The data query.
/// </param>
/// <param name="format">
/// The format.
/// </param>
/// <exception cref="Org.Sdmxsource.Sdmx.Api.Exception.SdmxNoResultsException">
/// This dataflow uses SDMX v2.0 only
/// DataStructureDefinition.
/// </exception>
private static void ValidateSdmxV20(IBaseDataQuery dataQuery, BaseConstantType <BaseDataFormatEnumType> format)
{
if (!dataQuery.DataStructure.IsCompatible(SdmxSchema.GetFromEnum(SdmxSchemaEnumType.VersionTwo)))
{
// TODO check java message/error in this case
throw new SdmxNoResultsException("This dataflow uses SDMX v2.1 only DataStructureDefinition.");
}
switch (format.EnumType)
{
case BaseDataFormatEnumType.Null:
break;
case BaseDataFormatEnumType.Generic:
case BaseDataFormatEnumType.Compact:
case BaseDataFormatEnumType.Utility:
case BaseDataFormatEnumType.Edi:
ValidateSdmxV20TimeSeries(dataQuery);
break;
case BaseDataFormatEnumType.CrossSectional:
ValidateErrors(Validator.ValidateForCrossSectional(dataQuery.DataStructure));
break;
default:
throw new SdmxSemmanticException("SDMX v2.0 Unsupported format " + format);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="DataParseMetadata"/> class.
/// </summary>
/// <param name="sourceData">
/// The readable data location
/// </param>
/// <param name="outPutStream">
/// The output stream
/// </param>
/// <param name="outputSchemaVersion">
/// The output schema version
/// </param>
/// <param name="keyFamily">
/// The key family
/// </param>
public DataParseMetadata(IReadableDataLocation sourceData, Stream outPutStream, SdmxSchema outputSchemaVersion, IDataStructureObject keyFamily)
{
this._sourceData = sourceData;
this._outPutStream = outPutStream;
this._dataStructure = keyFamily;
this._outputSchemaVersion = outputSchemaVersion;
}
/// <summary>
/// Builds the query structure for REST for the specified <paramref name="schema"/>.
/// </summary>
/// <param name="schema">
/// The SDMX schema version.
/// </param>
/// <param name="principal">
/// The principal.
/// </param>
/// <returns>
/// The <see cref="IController{IRestStructureQuery,XmlWriter}"/>.
/// </returns>
public IController <IRestStructureQuery, XmlWriter> BuildQueryStructureRest(SdmxSchema schema, DataflowPrincipal principal)
{
IWriterBuilder <IStructureWriterManager, XmlWriter> structureManagerBuilder = new StructureBuilder(WebServiceEndpoint.StandardEndpoint, schema);
StructureOutputFormatEnumType outputFormat;
IAuthMutableStructureSearchManager authMutableStructureSearchManager;
IMutableStructureSearchManager mutableStructureSearchManager;
switch (schema.EnumType)
{
case SdmxSchemaEnumType.VersionTwo:
authMutableStructureSearchManager = this._authMutableStructureSearchManagerV20;
mutableStructureSearchManager = this._mutableStructureSearchManagerV20;
outputFormat = StructureOutputFormatEnumType.SdmxV2StructureDocument;
break;
default:
authMutableStructureSearchManager = this._authMutableStructureSearchManagerV21;
mutableStructureSearchManager = this._mutableStructureSearchManagerV21;
outputFormat = StructureOutputFormatEnumType.SdmxV21StructureDocument;
break;
}
IResponseGenerator <XmlWriter, ISdmxObjects> responseGenerator = new StructureResponseGenerator(structureManagerBuilder, outputFormat);
var structureRequestController = new StructureRequestRestController <XmlWriter>(responseGenerator, mutableStructureSearchManager, authMutableStructureSearchManager, principal);
return(structureRequestController);
}
/// <summary>
/// Initializes static members of the <see cref="ControllerBuilder" /> class.
/// </summary>
static ControllerBuilder()
{
_log = LogManager.GetLogger(typeof(ControllerBuilder));
_compactDataFormat = BaseDataFormat.GetFromEnum(BaseDataFormatEnumType.Compact);
_genericDataFormat = BaseDataFormat.GetFromEnum(BaseDataFormatEnumType.Generic);
_crossSectional = BaseDataFormat.GetFromEnum(BaseDataFormatEnumType.CrossSectional);
_sdmxSchemaV20 = SdmxSchema.GetFromEnum(SdmxSchemaEnumType.VersionTwo);
_sdmxSchemaV21 = SdmxSchema.GetFromEnum(SdmxSchemaEnumType.VersionTwoPointOne);
}
/// <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, SdmxSchema sdmxSchema)
{
if (dataFormat == null)
{
return null;
}
return dataFormat.EnumType.GetDataType(sdmxSchema);
}
/// <summary>
/// Initializes a new instance of the <see cref="IoBase"/> class.
/// </summary>
/// <param name="namespaces">
/// The namespaces.
/// </param>
/// <param name="schema">
/// The SDMX schema version.
/// </param>
/// <exception cref="ArgumentNullException">
/// <paramref name="schema"/> is null
/// </exception>
protected IoBase(SdmxNamespaces namespaces, SdmxSchema schema)
{
if (schema == null)
{
throw new ArgumentNullException("schema");
}
this._targetSchema = schema;
this._namespaces = namespaces ?? CreateNamespaces(schema.EnumType);
}
/// <summary>
/// Initializes a new instance of the <see cref="AuthStructureRetrieverAvailableData"/> class.
/// </summary>
/// <exception cref="System.ArgumentNullException">
/// defaultHeader is null
/// </exception>
/// <exception cref="System.ArgumentNullException">
/// connectionStringSettings is null
/// </exception>
/// <exception cref="StructureRetrieverException">
/// Could not establish a connection to the mapping store DB
/// <see cref="StructureRetrieverException.ErrorType"/>
/// is set to
/// <see cref="StructureRetrieverErrorTypes.MappingStoreConnectionError"/>
/// </exception>
/// <param name="connectionStringSettings">
/// The connection to the "Mapping Store", from which the SDMX Structural metadata will be retrieved
/// </param>
/// <param name="sdmxSchema">
/// The SDMX Schema.
/// </param>
/// <exception cref="ArgumentNullException">
/// defaultHeader or connectionStringSettings is null
/// </exception>
public AuthStructureRetrieverAvailableData(ConnectionStringSettings connectionStringSettings, SdmxSchema sdmxSchema)
{
if (connectionStringSettings == null)
{
throw new ArgumentNullException("connectionStringSettings");
}
IStructureSearchManagerFactory<IAuthMutableStructureSearchManager> factory = new AuthMutableStructureSearchManagerFactory();
this._authStructureRetriever = factory.GetStructureSearchManager(connectionStringSettings, sdmxSchema);
}
/// <summary>
/// Initializes a new instance of the <see cref="StructureRequestV20Controller{TWriter}"/> class.
/// </summary>
/// <param name="responseGenerator">
/// The response generator.
/// </param>
/// <param name="structureSearchManager">
/// The structure search manager.
/// </param>
/// <param name="authStructureSearchManager">
/// The authentication structure search manager.
/// </param>
/// <param name="dataflowPrincipal">
/// The dataflow principal.
/// </param>
/// <exception cref="SdmxSemmanticException">
/// Operation not accepted with query used
/// </exception>
public StructureRequestV20Controller(
IResponseGenerator <TWriter, ISdmxObjects> responseGenerator,
IMutableStructureSearchManager structureSearchManager,
IAuthMutableStructureSearchManager authStructureSearchManager,
DataflowPrincipal dataflowPrincipal)
: base(responseGenerator, dataflowPrincipal)
{
this._structureSearchManager = structureSearchManager;
this._authStructureSearchManager = authStructureSearchManager;
SdmxSchema sdmxSchemaV20 = SdmxSchema.GetFromEnum(SdmxSchemaEnumType.VersionTwo);
this._manager = new QueryParsingManager(sdmxSchemaV20.EnumType, new QueryBuilder(null, new ConstrainQueryBuilderV2(), null));
}
/// <summary>
/// Initializes a new instance of the <see cref="StructureRequestV21AdvancedController{TWriter}"/> class.
/// </summary>
/// <param name="responseGenerator">
/// The response generator.
/// </param>
/// <param name="authStructureSearchManager">
/// The authentication structure search manager.
/// </param>
/// <param name="structureSearchManager">
/// The structure search manager.
/// </param>
/// <param name="principal">
/// The principal.
/// </param>
/// <param name="soapOperation">
/// The SOAP operation.
/// </param>
/// <exception cref="SdmxSemmanticException">
/// Operation not accepted with query used
/// </exception>
public StructureRequestV21AdvancedController(
IResponseGenerator <TWriter, ISdmxObjects> responseGenerator,
IAuthAdvancedMutableStructureSearchManager authStructureSearchManager,
IAdvancedMutableStructureSearchManager structureSearchManager,
DataflowPrincipal principal,
SoapOperation soapOperation)
: base(responseGenerator, principal)
{
this._authStructureSearchManager = authStructureSearchManager;
this._structureSearchManager = structureSearchManager;
SdmxSchema sdmxSchemaV21 = SdmxSchema.GetFromEnum(SdmxSchemaEnumType.VersionTwoPointOne);
this._manager = new QueryParsingManager(sdmxSchemaV21.EnumType);
this._rootNode = soapOperation.GetQueryRootElementV21();
}
/// <summary>
/// Processes the request.
/// </summary>
/// <param name="structure">The structure.</param>
/// <param name="agencyId">The agency id.</param>
/// <param name="resourceId">The resource id.</param>
/// <param name="version">The version.</param>
/// <param name="ctx">The current <see cref="WebOperationContext"/>.</param>
/// <returns>
/// The <see cref="Message" />.
/// </returns>
/// <exception cref="System.Web.HttpBrowserCapabilitiesBase"></exception>
/// <exception cref="WebFaultException{String}">
/// Cannot serve content type
/// </exception>
/// <exception cref="WebFaultException{String}">Cannot serve content type</exception>
private Message ProcessRequest(string structure, string agencyId, string resourceId, string version, WebOperationContext ctx)
{
Match match = Regex.Match(resourceId, @"[A-Za-z0-9\-]+$", RegexOptions.IgnoreCase);
if (!match.Success)
{
throw new WebFaultException(HttpStatusCode.BadRequest);
}
var defaultMediaType = StructureMediaType.GetFromEnum(StructureMediaEnumType.Structure).MediaTypeName;
var requestAccept = ctx.IncomingRequest.Accept;
Logger.Info("Got request Content type= " + requestAccept);
IList <ContentType> acceptHeaderElements = ctx.IncomingRequest.GetAcceptHeaderElements();
Func <ContentType, bool> predicate = type => StructureMediaType.GetTypeFromName(type.MediaType) != null;
var contentType = RestUtils.GetContentType(ctx, predicate, defaultMediaType);
string requestedVersion = HeaderUtils.GetVersionFromAccept(acceptHeaderElements, contentType.MediaType);
var selectedStructureMediaType = StructureMediaType.GetTypeFromName(contentType.MediaType);
var selectedMediaTypeWithVersion = selectedStructureMediaType.GetMediaTypeVersion(requestedVersion);
if (selectedMediaTypeWithVersion == null)
{
Logger.Error("Cannot serve content type: " + requestAccept);
throw new WebFaultException <string>("Cannot serve content type: " + requestAccept, HttpStatusCode.NotAcceptable);
}
Logger.Debug("Select mediatype with version if required: " + selectedMediaTypeWithVersion);
SdmxSchema schemaVersion = RestUtils.GetVersionFromMediaType(selectedMediaTypeWithVersion);
var context = HttpContext.Current;
var controller = this._controllerBuilder.BuildQueryStructureRest(schemaVersion, context.User as DataflowPrincipal);
Logger.Info("Selected representation info for the controller: format =" + "TODO" + " , smdx_schema=" + version);
IRestStructureQuery query = BuildRestQueryBean(structure, agencyId, resourceId, version, ctx.IncomingRequest.UriTemplateMatch.QueryParameters);
var streamController = controller.ParseRequest(query);
var charSetEncoding = RestUtils.GetCharSetEncoding(contentType);
var responseContentType = RestUtils.GetContentType(contentType, selectedMediaTypeWithVersion);
selectedMediaTypeWithVersion.CharSet = charSetEncoding.WebName;
return(ctx.CreateStreamResponse(
stream => RestUtils.StreamXml(schemaVersion, stream, streamController, charSetEncoding), responseContentType));
}
/// <summary>
/// Gets the data query visitor.
/// </summary>
/// <param name="dataFormat">The data format.</param>
/// <param name="sdmxSchema">The SDMX schema.</param>
/// <returns>The <see cref="IDataQueryVisitor" />.</returns>
public IDataQueryVisitor GetDataQueryVisitor(DataType dataFormat, SdmxSchema sdmxSchema)
{
List<IDataQueryVisitor> dataQueryVisitors = new List<IDataQueryVisitor>();
// first check if the current user is authorized to access this dataflow
IDataQueryVisitor authenticationVisitor = new AuthDataQueryVisitor(this._dataflowPrincipalManager);
dataQueryVisitors.Add(authenticationVisitor);
// then check if the data request is valid
IDataQueryVisitor validatingVisitor = new DataQueryValidatingVisitor(new DataRequestValidator(dataFormat));
dataQueryVisitors.Add(validatingVisitor);
// finally log the data request
IDataQueryVisitor dataflowLogVisitor = new DataflowLogVisitor(new DataflowLogManager(dataFormat));
dataQueryVisitors.Add(dataflowLogVisitor);
return new DataQueryVisitorComposite(dataQueryVisitors);
}
/// <summary>
/// The get version from media type.
/// </summary>
/// <param name="selectedMediaTypeWithVersion">
/// The selected media type with version.
/// </param>
/// <param name="format">
/// The format.
/// </param>
/// <returns>
/// The <see cref="SdmxSchema"/>.
/// </returns>
private static SdmxSchema GetVersionFromMediaType(ContentType selectedMediaTypeWithVersion, BaseDataFormat format)
{
SdmxSchema version = null;
switch (format.EnumType)
{
case BaseDataFormatEnumType.Edi:
version = SdmxSchema.GetFromEnum(SdmxSchemaEnumType.Edi);
break;
case BaseDataFormatEnumType.Csv:
version = SdmxSchema.GetFromEnum(SdmxSchemaEnumType.Csv);
break;
default:
version = RestUtils.GetVersionFromMediaType(selectedMediaTypeWithVersion);
break;
}
return(version);
}
/// <summary>
/// The process request.
/// </summary>
/// <param name="flowRef">
/// The flow ref.
/// </param>
/// <param name="key">
/// The key.
/// </param>
/// <param name="providerRef">
/// The provider ref.
/// </param>
/// <param name="ctx">
/// The ctx.
/// </param>
/// <returns>
/// The <see cref="Message"/>.
/// </returns>
/// <exception cref="WebFaultException{T}">
/// </exception>
private Message ProcessRequest(string flowRef, string key, string providerRef, WebOperationContext ctx)
{
var requestAccept = ctx.IncomingRequest.Accept;
Logger.Info("Got request Content type= " + requestAccept);
IList <ContentType> acceptHeaderElements = ctx.IncomingRequest.GetAcceptHeaderElements();
var defaultMediaType = DataMediaType.GetFromEnum(DataMediaEnumType.GenericData).MediaType;
var contentType = RestUtils.GetContentType(ctx, h => DataMediaType.GetTypeFromName(h.MediaType) != null, defaultMediaType);
string requestedVersion = HeaderUtils.GetVersionFromAccept(acceptHeaderElements, contentType.MediaType);
var datamediaType = DataMediaType.GetTypeFromName(contentType.MediaType);
var selectedMediaTypeWithVersion = datamediaType.GetMediaTypeVersion(requestedVersion);
if (selectedMediaTypeWithVersion == null)
{
Logger.Error("Cannot serve content type: " + requestAccept);
throw new WebFaultException <string>("Cannot serve content type: " + requestAccept, HttpStatusCode.NotAcceptable);
}
Logger.Debug("Select mediatype with version if required: " + selectedMediaTypeWithVersion);
BaseDataFormat format = DataMediaType.GetTypeFromName(selectedMediaTypeWithVersion.MediaType).Format;
SdmxSchema version = GetVersionFromMediaType(selectedMediaTypeWithVersion, format);
Logger.Info("Selected representation info for the controller: format =" + format + " , smdx_schema=" + version);
IRestDataQuery query = this.BuildQueryBean(flowRef, key, providerRef, ctx.IncomingRequest.UriTemplateMatch.QueryParameters);
HttpContext context = HttpContext.Current;
var controller = this._controllerBuilder.BuildDataRest(context.User as DataflowPrincipal, format, version);
var streamController = controller.ParseRequest(query);
var charSetEncoding = RestUtils.GetCharSetEncoding(contentType);
var responseContentType = RestUtils.GetContentType(contentType, selectedMediaTypeWithVersion);
selectedMediaTypeWithVersion.CharSet = charSetEncoding.WebName;
return(ctx.CreateStreamResponse(stream => RestUtils.StreamXml(version, stream, streamController, charSetEncoding), responseContentType));
}
/// <summary>
/// The get version from media type.
/// </summary>
/// <param name="mediaType">
/// The media type.
/// </param>
/// <returns>
/// The <see cref="SdmxSchema"/>.
/// </returns>
public static SdmxSchema GetVersionFromMediaType(ContentType mediaType)
{
if (mediaType.Parameters == null)
{
return(SdmxSchema.GetFromEnum(SdmxSchemaEnumType.VersionTwoPointOne));
}
if (!mediaType.Parameters.ContainsKey("version"))
{
return(SdmxSchema.GetFromEnum(SdmxSchemaEnumType.VersionTwoPointOne));
}
if (mediaType.Parameters["version"].Equals("2.1"))
{
return(SdmxSchema.GetFromEnum(SdmxSchemaEnumType.VersionTwoPointOne));
}
if (mediaType.Parameters["version"].Equals("2.0"))
{
return(SdmxSchema.GetFromEnum(SdmxSchemaEnumType.VersionTwo));
}
return(null);
}
/// <summary>
/// Initializes a new instance of the <see cref="CrossSectionalWriterEngine"/> class.
/// </summary>
/// <param name="writer">
/// The output <see cref="XmlWriter"/>
/// </param>
/// <param name="sdmxVersion">
/// The SDMX Version.
/// </param>
public CrossSectionalWriterEngine(XmlWriter writer, SdmxSchema sdmxVersion)
: this(writer, sdmxVersion, true)
{
}
/// <summary>
/// Gets the simple data controller for SDMX v2.0 SOAP or REST.
/// </summary>
/// <param name="dataFormat">
/// The compact data format.
/// </param>
/// <param name="sdmxSchema">
/// The SDMX schema V20.
/// </param>
/// <param name="principal">
/// The principal.
/// </param>
/// <returns>
/// The <see cref="IController{XmlNode,XmlWriter}"/>.
/// </returns>
private SimpleDataController <XmlWriter> GetSimpleDataController(BaseDataFormat dataFormat, SdmxSchema sdmxSchema, DataflowPrincipal principal)
{
DataRequestValidator dataRequestValidator;
IResponseGenerator <XmlWriter, IDataQuery> simpleDataResponseGenerator;
if (dataFormat.EnumType == BaseDataFormatEnumType.CrossSectional)
{
if (sdmxSchema.EnumType != SdmxSchemaEnumType.VersionTwo)
{
throw new SdmxSemmanticException("Impossible request. Requested CrossSectional for SDMX v2.1.");
}
var dataWriterBuilder = new CrossDataWriterBuilder();
simpleDataResponseGenerator = new SimpleCrossDataResponseGenerator <XmlWriter>(this._retrievalWithCrossWriter, dataWriterBuilder);
dataRequestValidator = new DataRequestValidator(_crossSectional, _sdmxSchemaV20);
}
else
{
var dataWriterBuilder = new DataWriterBuilder(dataFormat, sdmxSchema);
simpleDataResponseGenerator = new SimpleDataResponseGenerator <XmlWriter>(this.GetDataRetrievalWithWriter(sdmxSchema.EnumType), dataWriterBuilder);
dataRequestValidator = new DataRequestValidator(dataFormat, sdmxSchema);
}
var dataController = new DataController <IDataQuery, XmlWriter>(simpleDataResponseGenerator);
IDataflowLogManager dataflowLogManager = new DataflowLogManager(dataFormat);
var requestLogDataController = new RequestLogDataController <IDataQuery, XmlWriter>(dataController, dataflowLogManager);
var validatingDataController = new ValidatingDataController <IDataQuery, XmlWriter>(requestLogDataController, dataRequestValidator);
var authDataController = new AuthDataController <IDataQuery, XmlWriter>(validatingDataController, principal);
var simpleDataController = new SimpleDataController <XmlWriter>(authDataController, this._mappingStoreSdmxObjectRetrievalManager);
return(simpleDataController);
}
/// <summary>
/// Initializes a new instance of the <see cref="DataStreamWriterBase"/> class.
/// </summary>
/// <param name="writer">
/// The writer.
/// </param>
/// <param name="namespaces">
/// The namespaces.
/// </param>
/// <param name="schema">
/// The schema.
/// </param>
protected DataStreamWriterBase(XmlWriter writer, SdmxNamespaces namespaces, SdmxSchema schema)
: base(writer, namespaces, schema)
{
Validate(namespaces);
}
/// <summary>
/// Builds the query structure for REST for the specified <paramref name="schema"/>.
/// </summary>
/// <param name="schema">
/// The SDMX schema version.
/// </param>
/// <param name="principal">
/// The principal.
/// </param>
/// <returns>
/// The <see cref="IController{IRestStructureQuery,XmlWriter}"/>.
/// </returns>
public IController<IRestStructureQuery, XmlWriter> BuildQueryStructureRest(SdmxSchema schema, DataflowPrincipal principal)
{
IWriterBuilder<IStructureWriterManager, XmlWriter> structureManagerBuilder = new StructureBuilder(WebServiceEndpoint.StandardEndpoint, schema);
StructureOutputFormatEnumType outputFormat;
IAuthMutableStructureSearchManager authMutableStructureSearchManager;
IMutableStructureSearchManager mutableStructureSearchManager;
switch (schema.EnumType)
{
case SdmxSchemaEnumType.VersionTwo:
authMutableStructureSearchManager = this._authMutableStructureSearchManagerV20;
mutableStructureSearchManager = this._mutableStructureSearchManagerV20;
outputFormat = StructureOutputFormatEnumType.SdmxV2StructureDocument;
break;
default:
authMutableStructureSearchManager = this._authMutableStructureSearchManagerV21;
mutableStructureSearchManager = this._mutableStructureSearchManagerV21;
outputFormat = StructureOutputFormatEnumType.SdmxV21StructureDocument;
break;
}
IResponseGenerator<XmlWriter, ISdmxObjects> responseGenerator = new StructureResponseGenerator(structureManagerBuilder, outputFormat);
var structureRequestController = new StructureRequestRestController<XmlWriter>(responseGenerator, mutableStructureSearchManager, authMutableStructureSearchManager, principal);
return structureRequestController;
}
public string GetSchemaLocation(SdmxSchema schemaVersion)
{
return schemaLocationMap[schemaVersion];
}
/// <summary>
/// Gets the authentication mutable structure search manager.
/// </summary>
/// <param name="sdmxSchema">The SDMX schema.</param>
/// <returns>The <see cref="IAuthMutableStructureSearchManager"/>.</returns>
public virtual IAuthMutableStructureSearchManager GetAuthMutableStructureSearch(SdmxSchema sdmxSchema)
{
return this._decorated.GetAuthMutableStructureSearch(sdmxSchema);
}
/// <summary>
/// Initializes a new instance of the <see cref="CompactDataWriterEngine"/> class.
/// </summary>
/// <param name="writer">
/// The writer.
/// </param>
/// <param name="schema">
/// The schema.
/// </param>
public CompactDataWriterEngine(XmlWriter writer, SdmxSchema schema)
: base(writer, schema)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="CompactDataWriterEngine"/> class.
/// </summary>
/// <param name="outStream">The out stream.</param>
/// <param name="schemaVersion">The schema version.</param>
public CompactDataWriterEngine(Stream outStream, SdmxSchema schemaVersion)
: this(outStream, schemaVersion, Encoding.UTF8)
{
}
/// <summary>
/// Gets the authentication mutable structure search.
/// </summary>
/// <param name="sdmxSchema">The SDMX schema.</param>
/// <returns>The <see cref="IAuthMutableStructureSearchManager" />.</returns>
public IAuthMutableStructureSearchManager GetAuthMutableStructureSearch(SdmxSchema sdmxSchema)
{
return new SampleAuthStructureSearchManager(this._mutableStructureSearchManager);
}
/// <summary>
/// Gets the data retrieval.
/// </summary>
/// <param name="sdmxSchema">The SDMX schema.</param>
/// <returns>The <see cref="ISdmxDataRetrievalWithWriter" />.</returns>
public ISdmxDataRetrievalWithWriter GetDataRetrieval(SdmxSchema sdmxSchema)
{
return new SampleDataRetriever(sdmxSchema);
}
/// <summary>
/// Builds the specified writer engine.
/// </summary>
/// <param name="writer">The writer.</param>
/// <param name="actions">The actions.</param>
/// <returns>
/// The <see cref="ICrossSectionalWriterEngine" />.
/// </returns>
public ICrossSectionalWriterEngine Build(XmlWriter writer, Queue <Action> actions)
{
return(new DelayedCrossWriterEngine(actions, new CrossSectionalWriterEngine(writer, SdmxSchema.GetFromEnum(SdmxSchemaEnumType.VersionTwo))));
}
/// <summary>
/// Write a DataMessage in XmlWriter calling WriteTimeSeriesData or WriteFlatData or WriteCrossSectional
/// </summary>
/// <param name="writer">Stream Destination</param>
public override void WriteDataMessage(IFlyWriter writer)
{
try
{
IDataWriterEngine dataWriterEngine = null;
switch (MessageType)
{
case MessageTypeEnum.GenericData_21:
dataWriterEngine = new GenericDataWriterEngine(writer.__SdmxXml, SdmxSchema.GetFromEnum(SdmxSchemaEnumType.VersionTwoPointOne));
break;
case MessageTypeEnum.GenericTimeSeries_21:
dataWriterEngine = new GenericDataWriterEngine(writer.__SdmxXml, SdmxSchema.GetFromEnum(SdmxSchemaEnumType.VersionTwoPointOne));
break;
case MessageTypeEnum.StructureSpecific_21:
dataWriterEngine = new CompactDataWriterEngine(writer.__SdmxXml, SdmxSchema.GetFromEnum(SdmxSchemaEnumType.VersionTwoPointOne));
break;
case MessageTypeEnum.StructureSpecificTimeSeries_21:
dataWriterEngine = new CompactDataWriterEngine(writer.__SdmxXml, SdmxSchema.GetFromEnum(SdmxSchemaEnumType.VersionTwoPointOne));
break;
}
isFlat = false;
if (!string.IsNullOrEmpty(this.DimensionAtObservation) && this.DimensionAtObservation == "AllDimensions")
{
isFlat = true;
}
//Da capire!!!! perche in teoria le crossSectional dovrebbero essere GenericData_21 e StructureSpecific_21 mentre le atre 2 sono TimeSeries
//Ma le CommonApi non supportano le TimeSeries e quelle che in teoria sono Cross in realtà sono TimeSeries
//WriteCrossSectional(ref writer);
//return;
if (dataWriterEngine == null)
{
throw new SdmxException(this, FlyExceptionObject.FlyExceptionTypeEnum.InternalError, new Exception("No Type Message recognized"));
}
// write header
IHeader header = FlyConfiguration.HeaderSettings.GetHeader();
dataWriterEngine.WriteHeader(header);
// start dataset
DataStructureObjectImpl dsd = _retrievalManager._dsd;
dataWriterEngine.StartDataset(null, dsd.Immutated, null);
// Aggiungo dataset Title
if (FlyConfiguration.DatasetTitle && !string.IsNullOrEmpty(this._retrievalManager.DataFlowTitle))
{
dataWriterEngine.WriteAttributeValue("Title", this._retrievalManager.DataFlowTitle);
}
//GROUPS
if (_retrievalManager.Groups != null && _retrievalManager.Groups.Count > 0)
{
foreach (DataGroupObject group in _retrievalManager.Groups)
{
dataWriterEngine.StartGroup(group.GroupId);
foreach (GroupReferenceObject GroupKey in group.DimensionReferences)
{
dataWriterEngine.WriteGroupKeyValue(GroupKey.ConceptCode, GroupKey.ConceptValue.ToString());
}
foreach (GroupReferenceObject GroupAttribute in group.AttributeReferences)
{
dataWriterEngine.WriteAttributeValue(GroupAttribute.ConceptCode, GroupAttribute.ConceptValue.ToString());
}
}
}
this.LastSeriesKey = null;
if (isFlat)
{
WriteFlatData(dataWriterEngine);
}
else
{
WriteTimeSeriesData(dataWriterEngine);
}
dataWriterEngine.Close();
writer.__SdmxXml.Flush();
}
catch (SdmxException) { throw; }
catch (Exception ex)
{
throw new SdmxException(this, FlyExceptionObject.FlyExceptionTypeEnum.ErrorWriteDataMessage, ex);
}
}
/// <summary>
/// Builds the generic data controller for SDMX V21.
/// </summary>
/// <param name="principal">
/// The principal.
/// </param>
/// <param name="baseDataFormat">
/// The base data format.
/// </param>
/// <param name="sdmxSchema">
/// The SDMX schema.
/// </param>
/// <returns>
/// The <see cref="IController{XmlNode,XmlWriter}"/>.
/// </returns>
/// <exception cref="SdmxSemmanticException">
/// Impossible request. Requested CrossSectional for SDMX v2.1.
/// </exception>
public IController <IRestDataQuery, XmlWriter> BuildDataRest(DataflowPrincipal principal, BaseDataFormat baseDataFormat, SdmxSchema sdmxSchema)
{
return(this.GetSimpleDataController(baseDataFormat, sdmxSchema, principal));
}
/// <summary>
/// Initializes a new instance of the <see cref="CrossSectionalWriterEngine"/> class.
/// </summary>
/// <param name="writer">
/// The output <see cref="XmlWriter"/>
/// </param>
/// <param name="sdmxVersion">
/// The SDMX Version.
/// </param>
/// <param name="useEstatUrn">
/// The use ESTAT URN format.
/// </param>
public CrossSectionalWriterEngine(XmlWriter writer, SdmxSchema sdmxVersion, bool useEstatUrn)
: base(writer, sdmxVersion)
{
if (sdmxVersion.EnumType == SdmxSchemaEnumType.VersionTwoPointOne)
{
throw new ArgumentException(Resources.ErrorCrossWith21, "sdmxVersion");
}
this.Namespaces.UseEstatUrn = useEstatUrn;
}
/// <summary>
/// Handles the structure request.
/// </summary>
/// <param name="query">The query.</param>
/// <param name="schemaVersion">The schema version.</param>
/// <param name="encoding">The encoding.</param>
/// <returns>The <see cref="IStreamController{Stream}" />.</returns>
public IStreamController<Stream> ParseRequest(IRestStructureQuery query, SdmxSchema schemaVersion, Encoding encoding)
{
var structureOutputFormat = schemaVersion == SdmxSchemaEnumType.VersionTwoPointOne
? StructureOutputFormat.GetFromEnum(StructureOutputFormatEnumType.SdmxV21StructureDocument)
: StructureOutputFormat.GetFromEnum(StructureOutputFormatEnumType.SdmxV2StructureDocument);
var sdmxObjects = this._retrieverManager.ParseRequest(schemaVersion, query, this._dataflowPrincipalManager.GetCurrentPrincipal());
return this.GetStreamController(structureOutputFormat, sdmxObjects, encoding);
}
/// <summary>
/// Initializes a new instance of the <see cref="CrossSectionalWriterEngine"/> class.
/// </summary>
/// <param name="writer">
/// The output <see cref="XmlWriter"/>
/// </param>
/// <param name="namespaces">
/// The output XML message namespaces.
/// </param>
/// <param name="sdmxSchema">
/// The SDMX version.
/// </param>
/// <exception cref="ArgumentNullException">
/// <paramref name="namespaces"/> is null
/// </exception>
public CrossSectionalWriterEngine(XmlWriter writer, SdmxNamespaces namespaces, SdmxSchema sdmxSchema)
: base(writer, namespaces, sdmxSchema)
{
if (sdmxSchema.EnumType == SdmxSchemaEnumType.VersionTwoPointOne)
{
throw new ArgumentException(Resources.ErrorCrossWith21, "sdmxSchema");
}
}
/// <summary>
/// Write a DataMessage in XmlWriter
/// </summary>
/// <param name="writer">Stream Destination</param>
public override void WriteDataMessage(IFlyWriter writer)
{
try
{
IDataWriterEngine dataWriterEngine = null;
switch (MessageType)
{
case MessageTypeEnum.Compact_20:
dataWriterEngine = new CompactDataWriterEngine(writer.__SdmxXml, SdmxSchema.GetFromEnum(SdmxSchemaEnumType.VersionTwo));
break;
case MessageTypeEnum.Generic_20:
dataWriterEngine = new GenericDataWriterEngine(writer.__SdmxXml, SdmxSchema.GetFromEnum(SdmxSchemaEnumType.VersionTwo));
break;
case MessageTypeEnum.CrossSectional_20:
break;
}
if (dataWriterEngine == null)
{
throw new SdmxException(this, FlyExceptionObject.FlyExceptionTypeEnum.InternalError, new Exception("No Type Message recognized"));
}
// write header
dataWriterEngine.WriteHeader(FlyConfiguration.HeaderSettings.GetHeader());
// start dataset
DataStructureObjectImpl dsd = _retrievalManager._dsd;
dataWriterEngine.StartDataset(null, dsd.Immutated, null);
// Aggiungo dataset Title
if (FlyConfiguration.DatasetTitle && !string.IsNullOrEmpty(this._retrievalManager.DataFlowTitle))
{
dataWriterEngine.WriteAttributeValue("Title", this._retrievalManager.DataFlowTitle);
}
this.LastSeriesKey = null;
List <DataMessageObject> dmo = _tableResponse.GetNext();
if (dmo != null)
{
//Aggiungo gli Attributi di Dataset
foreach (DataMessageObject seriesAttribute in dmo.FindAll(att => OnlyDatasetAttribute(att)))
{
dataWriterEngine.WriteAttributeValue(seriesAttribute.ColImpl.ConceptObjectCode, seriesAttribute.Val.ToString());
}
//GROUPS
if (_retrievalManager.Groups != null && _retrievalManager.Groups.Count > 0)
{
foreach (DataGroupObject group in _retrievalManager.Groups)
{
dataWriterEngine.StartGroup(group.GroupId);
foreach (GroupReferenceObject GroupKey in group.DimensionReferences)
{
dataWriterEngine.WriteGroupKeyValue(GroupKey.ConceptCode, GroupKey.ConceptValue.ToString());
}
foreach (GroupReferenceObject GroupAttribute in group.AttributeReferences)
{
dataWriterEngine.WriteAttributeValue(GroupAttribute.ConceptCode, GroupAttribute.ConceptValue.ToString());
}
}
}
do
{
if (dmo == null)
{
break;
}
//SERIE
if (CheckChanged(dmo))
{
dataWriterEngine.StartSeries();
foreach (DataMessageObject seriesKey in dmo.FindAll(dim => OnlySeriesKey(dim)))
{
dataWriterEngine.WriteSeriesKeyValue(seriesKey.ColImpl.ConceptObjectCode, seriesKey.Val.ToString());
}
foreach (DataMessageObject seriesAttribute in dmo.FindAll(att => OnlySeriesAttribute(att)))
{
dataWriterEngine.WriteAttributeValue(seriesAttribute.ColImpl.ConceptObjectCode, seriesAttribute.Val.ToString());
}
}
//OBSERVATION
DataMessageObject val = dmo.Find(dimV => dimV.ColImpl.ConceptType == ConceptTypeEnum.Attribute && ((IAttributeConcept)dimV.ColImpl).IsValueAttribute);
DataMessageObject time = dmo.Find(dimT => dimT.ColImpl.ConceptType == ConceptTypeEnum.Dimension && ((IDimensionConcept)dimT.ColImpl).DimensionType == DimensionTypeEnum.Time);
dataWriterEngine.WriteObservation(time.Val.ToString(), val.Val.ToString());
foreach (DataMessageObject seriesAttribute in dmo.FindAll(att => OnlyObservationAttribute(att)))
{
if (seriesAttribute.Val.ToString() != String.Empty)
{
dataWriterEngine.WriteAttributeValue(seriesAttribute.ColImpl.ConceptObjectCode, seriesAttribute.Val.ToString());
}
}
dmo = _tableResponse.GetNext();
} while (dmo != null);
}
dataWriterEngine.Close();
writer.__SdmxXml.Flush();
}
catch (SdmxException) { throw; }
catch (Exception ex)
{
throw new SdmxException(this, FlyExceptionObject.FlyExceptionTypeEnum.ErrorWriteDataMessage, ex);
}
}
/// <summary>
/// Gets an instance of <see cref="ISdmxDataRetrievalWithCrossWriter"/> using the provided SDMX version.
/// </summary>
/// <param name="sdmxSchema">The SDMX schema version.</param>
/// <returns>The <see cref="ISdmxDataRetrievalWithCrossWriter"/>.</returns>
public virtual ISdmxDataRetrievalWithCrossWriter GetDataRetrievalWithCross(SdmxSchema sdmxSchema)
{
return this._decorated.GetDataRetrievalWithCross(sdmxSchema);
}
/// <summary>
/// Streams the structural metadata.
/// </summary>
/// <param name="schemaVersion">The schema version.</param>
/// <param name="stream">The stream.</param>
/// <param name="streamController">The stream controller.</param>
/// <param name="encoding">The response encoding.</param>
public static void StreamXml(SdmxSchema schemaVersion, Stream stream, IStreamController <XmlWriter> streamController, Encoding encoding)
{
try
{
if (schemaVersion.IsXmlFormat())
{
using (var writer = XmlWriter.Create(stream, new XmlWriterSettings {
Indent = true, Encoding = encoding
}))
{
var actions = new Queue <Action>();
streamController.StreamTo(writer, actions);
writer.Flush();
}
}
else
{
throw new SdmxNotImplementedException(string.Format(CultureInfo.InvariantCulture, "Not supported {0}", schemaVersion.ToEnglishString()));
}
}
catch (SdmxResponseSizeExceedsLimitException e)
{
// error is on payload.
_logger.Warn(e.Message, e);
}
catch (SdmxResponseTooLargeException e)
{
// error is on payload.
_logger.Warn(e.Message, e);
}
catch (Exception e)
{
_logger.Error(e.Message, e);
// HACK.
// The following is needed because for some reason WebOperationContext.CreateStreamResponse closes the connection and does not return a
// status code and/or error message to the user.
var normalizedException = _builder.Build(e);
//// Setting the WebOperationContext does not seem to work....
//// WebOperationContext.Current.OutgoingResponse.StatusCode = normalizedException.StatusCode;
try
{
HttpContext.Current.Response.StatusCode = (int)normalizedException.StatusCode;
}
catch (HttpException ex)
{
_logger.Error(e.Message, ex);
// Not much we can do. We already sent the header Throw the original exception.
throw e;
}
HttpContext.Current.Response.ContentType = "text/html;";
using (var streamWriter = new StreamWriter(stream))
{
streamWriter.WriteLine("{0} - {1}", normalizedException.Message, normalizedException.Detail);
streamWriter.Flush();
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="DataStreamWriterBase"/> class.
/// </summary>
/// <param name="writer">
/// The writer.
/// </param>
/// <param name="schema">
/// The schema.
/// </param>
protected DataStreamWriterBase(XmlWriter writer, SdmxSchema schema)
: this(writer, CreateDataNamespaces(schema.EnumType), schema)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="DataRequestValidator"/> class.
/// Initializes a new instance of the <see cref="T:System.Object"/> class.
/// </summary>
/// <param name="format">
/// The format.
/// </param>
/// <param name="schema">
/// The schema.
/// </param>
public DataRequestValidator(BaseDataFormat format, SdmxSchema schema)
{
this._format = format;
this._schema = schema;
}
/// <summary>
/// Builds the CSV ziped data controller for SDMX V21.
/// </summary>
/// <param name="principal">
/// The principal.
/// </param>
/// <param name="baseDataFormat">
/// The base data format.
/// </param>
/// <param name="sdmxSchema">
/// The SDMX schema.
/// </param>
/// <returns>
/// The <see cref="IController{XmlNode,XmlWriter}"/>.
/// </returns>
/// <exception cref="SdmxSemmanticException">
/// Impossible request. Requested CrossSectional for SDMX v2.1.
/// </exception>
public IController<IRestDataQuery, CsvZipTextWriter> BuildCsvZipDataRest(DataflowPrincipal principal, BaseDataFormat baseDataFormat, SdmxSchema sdmxSchema)
{
CsvZipDataController<CsvZipTextWriter> CsvZipDataController;
var dataWriterBuilder = new CsvZipDataWriterBuilder(baseDataFormat, sdmxSchema);
var CsvZipDataResponseGenerator = new CsvZipDataResponseGenerator<CsvZipTextWriter>(this.GetDataRetrievalWithWriter(sdmxSchema.EnumType), dataWriterBuilder);
CsvZipDataController = new CsvZipDataController<CsvZipTextWriter>(CsvZipDataResponseGenerator, new DataRequestValidator(baseDataFormat, sdmxSchema), principal);
return CsvZipDataController;
}
/// <summary>
/// Initializes a new instance of the <see cref="CrossSectionalWriterEngine"/> class.
/// </summary>
/// <param name="writer">
/// The output <see cref="XmlWriter"/>
/// </param>
/// <param name="sdmxVersion">
/// The SDMX Version.
/// </param>
public CrossSectionalWriterEngine(Stream writer, SdmxSchema sdmxVersion)
: this(writer, sdmxVersion, Encoding.UTF8)
{
}
/// <summary>
/// Gets the CsvZip data controller for SDMX v2.0 SOAP or REST.
/// </summary>
/// <param name="dataFormat">
/// The compact data format.
/// </param>
/// <param name="sdmxSchema">
/// The SDMX schema V20.
/// </param>
/// <param name="principal">
/// The principal.
/// </param>
/// <returns>
/// The <see cref="IController{XmlNode,XmlWriter}"/>.
/// </returns>
private CsvZipDataController<CsvZipTextWriter> GetCsvZipDataController(BaseDataFormat dataFormat, SdmxSchema sdmxSchema, DataflowPrincipal principal)
{
CsvZipDataController<CsvZipTextWriter> CsvZipDataController;
var dataWriterBuilder = new CsvZipDataWriterBuilder(dataFormat, sdmxSchema);
var CsvZipDataResponseGenerator = new CsvZipDataResponseGenerator<CsvZipTextWriter>(this.GetDataRetrievalWithWriter(sdmxSchema.EnumType), dataWriterBuilder);
CsvZipDataController = new CsvZipDataController<CsvZipTextWriter>(CsvZipDataResponseGenerator, new DataRequestValidator(dataFormat, sdmxSchema), principal);
return CsvZipDataController;
}
/// <summary>
/// Initializes a new instance of the <see cref="CrossSectionalWriterEngine" /> class.
/// </summary>
/// <param name="writer">The output <see cref="XmlWriter" /></param>
/// <param name="sdmxVersion">The SDMX Version.</param>
/// <param name="encoding">The encoding.</param>
public CrossSectionalWriterEngine(Stream writer, SdmxSchema sdmxVersion, Encoding encoding)
: this(XmlWriter.Create(writer, new XmlWriterSettings() { Encoding = encoding }), sdmxVersion)
{
this._closeXmlWriter = true;
}
/// <summary>
/// Gets the data retrieval with cross.
/// </summary>
/// <param name="sdmxSchema">The SDMX schema.</param>
/// <returns>The <see cref="ISdmxDataRetrievalWithCrossWriter" />.</returns>
public ISdmxDataRetrievalWithCrossWriter GetDataRetrievalWithCross(SdmxSchema sdmxSchema)
{
return new SampleDataRetrieverCross();
}
/// <summary>
/// Gets the Advanced (SDMX v2.1 SOAP) data controller.
/// </summary>
/// <param name="dataFormat">
/// The compact data format.
/// </param>
/// <param name="sdmxSchema">
/// The SDMX schema V20.
/// </param>
/// <param name="principal">
/// The principal.
/// </param>
/// <returns>
/// The <see cref="IController{XmlNode,XmlWriter}"/>.
/// </returns>
private IController <Message, XmlWriter> GetAdvancedDataController(BaseDataFormat dataFormat, SdmxSchema sdmxSchema, DataflowPrincipal principal)
{
var dataWriterBuilder = new DataWriterBuilder(dataFormat, sdmxSchema);
var dataResponseGenerator = new AdvancedDataResponseGenerator <XmlWriter>(this._advancedRetrievalWithWriter, dataWriterBuilder);
var operation = dataFormat.GetSoapOperation(SdmxSchemaEnumType.VersionTwoPointOne);
var dataController = new DataController <IComplexDataQuery, XmlWriter>(dataResponseGenerator);
IDataflowLogManager dataflowLogManager = new DataflowLogManager(dataFormat);
var requestLogDataController = new RequestLogDataController <IComplexDataQuery, XmlWriter>(dataController, dataflowLogManager);
var validatingDataController = new ValidatingDataController <IComplexDataQuery, XmlWriter>(requestLogDataController, new DataRequestValidator(dataFormat, sdmxSchema));
var authDataController = new AuthDataController <IComplexDataQuery, XmlWriter>(validatingDataController, principal);
return(new AdvancedDataController <XmlWriter>(operation, authDataController, this._mappingStoreSdmxObjectRetrievalManager));
}
/// <summary>
/// Initializes a new instance of the <see cref="CompactDataWriterEngine"/> class.
/// </summary>
/// <param name="writer">
/// The writer.
/// </param>
/// <param name="namespaces">
/// The namespaces.
/// </param>
/// <param name="schema">
/// The schema.
/// </param>
public CompactDataWriterEngine(XmlWriter writer, SdmxNamespaces namespaces, SdmxSchema schema)
: base(writer, namespaces, schema)
{
}
/// <summary>
/// Gets the mutable structure search.
/// </summary>
/// <param name="sdmxSchema">The SDMX schema.</param>
/// <returns>The <see cref="IMutableStructureSearchManager" />.</returns>
public IMutableStructureSearchManager GetMutableStructureSearch(SdmxSchema sdmxSchema)
{
return this._mutableStructureSearchManager;
}
/// <summary>
/// Initializes a new instance of the <see cref="CompactDataWriterEngine" /> class.
/// </summary>
/// <param name="outStream">The out stream.</param>
/// <param name="schemaVersion">The schema version.</param>
/// <param name="encoding">The encoding.</param>
public CompactDataWriterEngine(Stream outStream, SdmxSchema schemaVersion, Encoding encoding)
: this(XmlWriter.Create(outStream, new XmlWriterSettings { Encoding = encoding }), schemaVersion)
{
this._closeXmlWriter = true;
}
/// <summary>
/// Initializes a new instance of the <see cref="DataWriterBuilder"/> class.
/// </summary>
/// <param name="dataFormat">
/// The data Format.
/// </param>
/// <param name="sdmxSchema">
/// The sdmx Schema.
/// </param>
public DataWriterBuilder(BaseDataFormat dataFormat, SdmxSchema sdmxSchema)
{
this._dataFormat = dataFormat;
this._sdmxSchema = sdmxSchema;
}
/// <summary>
/// Gets the structure response.
/// </summary>
/// <param name="request">The request.</param>
/// <param name="sdmxSchema">The SDMX schema.</param>
/// <returns>The <see cref="IMutableObjects" />.</returns>
private ISdmxObjects GetStructureResponse(XmlNode request, SdmxSchema sdmxSchema)
{
ISdmxObjects structureResponse;
using (var readableDataLocation = request.GetReadableDataLocation())
{
structureResponse = this._retrieverManager.ParseRequest(sdmxSchema, readableDataLocation, this._dataflowPrincipalManager.GetCurrentPrincipal());
}
return structureResponse;
}
/// <summary>
/// Initializes a new instance of the <see cref="CrossSectionalWriterEngine"/> class.
/// </summary>
/// <param name="writer">
/// The output <see cref="XmlWriter"/>
/// </param>
/// <param name="sdmxVersion">
/// The SDMX Version.
/// </param>
/// <exception cref="ArgumentNullException">
/// keyFamily is null
/// </exception>
public CrossSectionalWriterEngine(Stream writer, SdmxSchema sdmxVersion)
: this(XmlWriter.Create(writer), sdmxVersion)
{
this._closeXmlWriter = true;
}
/// <summary>
/// Initializes a new instance of the <see cref="DataRequestValidator"/> class.
/// Initializes a new instance of the <see cref="T:System.Object"/> class.
/// </summary>
/// <param name="format">
/// The format.
/// </param>
/// <param name="schema">
/// The schema.
/// </param>
public DataRequestValidator(BaseDataFormat format, SdmxSchema schema)
{
this._format = format;
this._schema = schema;
}
/// <summary>
/// Initializes a new instance of the <see cref="StructureBuilder"/> class.
/// </summary>
/// <param name="endpoint">
/// The endpoint.
/// </param>
/// <param name="schema">
/// The schema.
/// </param>
public StructureBuilder(WebServiceEndpoint endpoint, SdmxSchema schema)
{
this._endpoint = endpoint;
this._schema = schema;
}
