/// <summary>
/// First Parse Message arrived from external process for REST SDMX
/// </summary>
/// <param name="query">data parsed from Sdmx CommonAPI</param>
public void ParseQueryMessageREST(IRestDataQuery query)
{
HaveError = false;
ErrorMessage = null;
try
{
ISdmxParsingObject pc = new SdmxParsingObject(SdmxStructureEnumType.Any)
{
AgencyId = query.FlowRef.AgencyId,
_version = query.FlowRef.Version,
};
pc.PreliminarCheck();
RetrievalManagerObject = new RetrievalManager(DataFlowElementId, this.VersionTypeResp);
//RetrievalManagerObject.
WhereStatement = new DataWhereStatment(query);
}
catch (SdmxException sdmxerr)
{
HaveError = true;
ErrorMessage = sdmxerr;
}
catch (Exception err)
{
HaveError = true;
ErrorMessage = new SdmxException(this, FlyExceptionObject.FlyExceptionTypeEnum.ParsingQueryError, err);
}
}
/// <summary>
/// Parse request from <paramref name="input"/>
/// </summary>
/// <param name="input">
/// The reader for the SDMX-ML or REST request
/// </param>
/// <returns>
/// The <see cref="IStreamController{TWriter}"/>.
/// </returns>
public IStreamController <TWriter> ParseRequest(IRestDataQuery input)
{
if (input == null)
{
throw new SdmxSemmanticException(Resources.ErrorOperationNotAccepted);
}
IDataQuery dataQuery = new DataQueryImpl(input, this._sdmxRetrievalManager);
this._log.DebugFormat("Converted REST data query '{0}' to IDataQuery {1}", input, dataQuery);
return(this.ParseRequest(dataQuery));
}
/// <summary>
/// Prepare a Parsing of Query SDMX REST
/// </summary>
/// <param name="WhereStatementREST">Query Parameter</param>
private void ParseGroupREST(IRestDataQuery WhereStatementREST)
{
try
{
if (WhereStatementREST == null)
{
throw new SdmxException(this, FlyExceptionObject.FlyExceptionTypeEnum.RetrivalParsingError);
}
IsRest = true;
Query = WhereStatementREST;
this.DimensionAtObservation = WhereStatementREST.DimensionAtObservation;
}
catch (SdmxException) { throw; }
catch (Exception ex)
{
throw new SdmxException(this, FlyExceptionObject.FlyExceptionTypeEnum.ParsingQueryError, ex);
}
}
/// <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>
/// Build from a REST query and a bean retrival manager
/// </summary>
/// <param name="dataQuery"></param>
/// <param name="retrievalManager"></param>
/// <exception cref="SdmxSemmanticException"></exception>
public DataQueryImpl(IRestDataQuery dataQuery, ISdmxObjectRetrievalManager retrievalManager)
{
this._lastUpdated = dataQuery.UpdatedAfter;
this._dataQueryDetail = dataQuery.QueryDetail ?? DataQueryDetail.GetFromEnum(DataQueryDetailEnumType.Full);
base.FirstNObservations = dataQuery.FirstNObservations;
base.LastNObservations = dataQuery.LastNObsertations;
if (ObjectUtil.ValidString(dataQuery.DimensionAtObservation))
{
this.DimensionAtObservation = dataQuery.DimensionAtObservation;
}
base.Dataflow = retrievalManager.GetMaintainableObject<IDataflowObject>(dataQuery.FlowRef.MaintainableReference);
if (base.Dataflow == null)
{
throw new SdmxNoResultsException("Data Flow could not be found for query : " + dataQuery.FlowRef);
}
base.DataStructure =
retrievalManager.GetMaintainableObject<IDataStructureObject>(base.Dataflow.DataStructureRef.MaintainableReference);
if (base.DataStructure == null)
{
throw new SdmxNoResultsException("DSD could not be found for query : " + base.Dataflow.DataStructureRef);
}
ISet<IDataProvider> dataProviders = new HashSet<IDataProvider>();
if (dataQuery.ProviderRef != null)
{
ISet<IDataProviderScheme> dataProviderSchemes =
retrievalManager.GetMaintainableObjects<IDataProviderScheme>(dataQuery.ProviderRef.MaintainableReference);
foreach (IDataProviderScheme currentDpScheme in dataProviderSchemes)
{
foreach (IDataProvider dataProvider in currentDpScheme.Items)
{
if (dataProvider.Id.Equals(dataQuery.ProviderRef.ChildReference.Id))
{
dataProviders.Add(dataProvider);
}
}
}
}
ISet<IDataQuerySelection> selections = new HashSet<IDataQuerySelection>();
if (dataQuery.QueryList.Count > 0)
{
int i = 0;
foreach (IDimension dimension in base.DataStructure.GetDimensions(SdmxStructureEnumType.Dimension, SdmxStructureEnumType.MeasureDimension).OrderBy(dimension => dimension.Position))
{
if (dataQuery.QueryList.Count <= i)
{
throw new SdmxSemmanticException(
"Not enough key values in query, expecting "
+ base.DataStructure.GetDimensions(SdmxStructureEnumType.Dimension, SdmxStructureEnumType.MeasureDimension).Count + " got "
+ dataQuery.QueryList.Count);
}
ISet<string> queriesForDimension = dataQuery.QueryList[i];
if (queriesForDimension != null && queriesForDimension.Count > 0)
{
IDataQuerySelection selectionsForDimension =
new DataQueryDimensionSelectionImpl(
dimension.Id,
new HashSet<string>(queriesForDimension));
selections.Add(selectionsForDimension);
}
i++;
}
}
if (ObjectUtil.ValidCollection(selections) || dataQuery.StartPeriod != null || dataQuery.EndPeriod != null)
{
_dataQuerySelectionGroups.Add(
new DataQuerySelectionGroupImpl(selections, dataQuery.StartPeriod, dataQuery.EndPeriod));
}
ValidateQuery();
}
/// <summary>
/// Execute the rest query, write the response out to the output stream based on the data format
/// </summary>
/// <param name="dataQuery">
/// The data query
/// </param>
/// <param name="dataFormat">
/// The data format
/// </param>
/// <param name="outPutStream">
/// The output stream
/// </param>
public void ExecuteQuery(IRestDataQuery dataQuery, IDataFormat dataFormat, Stream outPutStream)
{
IDataQuery query = new DataQueryImpl(dataQuery, this._objectRetrievalManager);
using (IDataWriterEngine dataWriterEngine = this._dataWriterManager.GetDataWriterEngine(dataFormat, outPutStream))
{
this._dataRetrievalWithWriter.GetData(query, dataWriterEngine);
}
}
/// <summary>
/// Create a instance of DataWhereStatment from RetrievalManager.BuildComplexDataQuery result for SDMX REST Version
/// </summary>
/// <param name="WhereStatementREST">IRestDataQuery <see cref="IRestDataQuery"/></param>
public DataWhereStatment(IRestDataQuery WhereStatementREST)
{
ParseGroupREST(WhereStatementREST);
}
