/// <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>
/// Adds components to the component map.
/// </summary>
/// <param name="retrievalManager">
/// The retrieval manager
/// </param>
/// <param name="crossRef">
/// The cross reference object
/// </param>
/// <param name="componentMap">
/// The components map
/// </param>
private void AddComponenents(ISdmxObjectRetrievalManager retrievalManager, ICrossReference crossRef, IDictionary<String, IComponent> componentMap)
{
switch (crossRef.TargetReference.EnumType)
{
case SdmxStructureEnumType.ProvisionAgreement:
IProvisionAgreementObject prov = retrievalManager.GetMaintainableObject<IProvisionAgreementObject>(crossRef);
if (prov == null)
{
prov = _beanRetrievalManager.GetMaintainableObject<IProvisionAgreementObject>(crossRef);
if (prov == null)
throw new CrossReferenceException(crossRef);
}
crossRef = prov.StructureUseage; //Drop through to the next switch statement
break;
case SdmxStructureEnumType.Dataflow:
IDataflowObject flow = retrievalManager.GetMaintainableObject<IDataflowObject>(crossRef);
if (flow == null)
{
flow = _beanRetrievalManager.GetMaintainableObject<IDataflowObject>(crossRef);
if (flow == null)
throw new CrossReferenceException(crossRef);
}
crossRef = flow.DataStructureRef; //Drop through to the next switch statement
break;
case SdmxStructureEnumType.Dsd:
IDataStructureObject dsd = retrievalManager.GetMaintainableObject<IDataStructureObject>(crossRef);
if (dsd == null)
{
dsd = _beanRetrievalManager.GetMaintainableObject<IDataStructureObject>(crossRef);
if (dsd == null)
throw new CrossReferenceException(crossRef);
}
foreach (IComponent currentComponent in dsd.Components)
componentMap.Add(currentComponent.Id, currentComponent);
break;
}
}
/// <summary>
/// Processes the dataWhere element to get the Provisionn Agreeement reference and retrieve the respective artefact bean.
/// If the provision agreement cannot be found it throws an exception.
/// </summary>
/// <param name="dataWhere">
/// The data where.
/// </param>
/// <param name="structureRetrievalManager">
/// The structure retrieval manager.
/// </param>
/// <returns>
/// The provision agreement object.
/// </returns>
private IProvisionAgreementObject GetProvisionAgreement(DataParametersAndType dataWhere, ISdmxObjectRetrievalManager structureRetrievalManager)
{
IProvisionAgreementObject provisionAgreement = null;
if (dataWhere.ProvisionAgreement != null && dataWhere.ProvisionAgreement.Count > 0)
{
var refBaseType = dataWhere.ProvisionAgreement[0].GetTypedRef<ProvisionAgreementRefType>();
string praAgency = refBaseType.agencyID;
string praId = refBaseType.id;
string praVersion = null;
if (refBaseType.version != null)
praVersion = refBaseType.version;
IMaintainableRefObject praRef = new MaintainableRefObjectImpl(praAgency, praId, praVersion);
provisionAgreement = structureRetrievalManager.GetMaintainableObject<IProvisionAgreementObject>(praRef);
if (provisionAgreement == null)
{
throw new SdmxNoResultsException("Provision Agreement not found: " + praRef);
}
}
return provisionAgreement;
}
/// <summary>
/// Processes the dataWhere element to get the DSD reference and retrieve the respective DSD.
/// It throws an exception if the DSD cannot be retrieved.
/// </summary>
/// <param name="dataWhere">
/// The data where.
/// </param>
/// <param name="structureRetrievalManager">
/// The structure retrieval manager.
/// </param>
/// <param name="dataFlow">
/// The data flow.
/// </param>
/// <returns>
/// The data structure object.
/// </returns>
private IDataStructureObject GetDataWhereDataStrucuture(DataParametersAndType dataWhere,
ISdmxObjectRetrievalManager structureRetrievalManager,
IDataflowObject dataFlow)
{
IDataStructureObject dataStructure = null;
if (dataWhere.DataStructure != null && dataWhere.DataStructure.Count > 0)
{
var refBaseType = dataWhere.DataStructure[0].GetTypedRef<DataStructureRefType>();
string dataStructureAgency = refBaseType.agencyID;
string dataStructureId = refBaseType.id;
string dataStructureVersion = null;
if (refBaseType.version != null)
dataStructureVersion = refBaseType.version;
IMaintainableRefObject dsdRef = new MaintainableRefObjectImpl(dataStructureAgency, dataStructureId, dataStructureVersion);
dataStructure = structureRetrievalManager.GetMaintainableObject<IDataStructureObject>(dsdRef);
if (dataStructure == null)
{
throw new SdmxNoResultsException("DSD not found: " + dsdRef);
}
}
else
{
IMaintainableRefObject dsdRef = dataFlow.DataStructureRef.MaintainableReference;
dataStructure = structureRetrievalManager.GetMaintainableObject<IDataStructureObject>(dsdRef);
if (dataStructure == null)
{
throw new SdmxNoResultsException("Data Structure not found: " + dsdRef);
}
}
return dataStructure;
}
/// <summary>
/// Processes the dataWhere element to get the dataflow reference and retrieve the respective dataflow.
/// It throws an exception if the dataflow retrieved is null
/// </summary>
/// <param name="dataWhere">
/// The data where.
/// </param>
/// <param name="structureRetrievalManager">
/// The structure retrieval manager.
/// </param>
/// <returns>
/// The data flow object.
/// </returns>
private IDataflowObject GetDataWhereDataFlow(DataParametersAndType dataWhere, ISdmxObjectRetrievalManager structureRetrievalManager)
{
IDataflowObject dataFlow = null;
if (dataWhere.Dataflow != null && dataWhere.Dataflow.Count > 0)
{
var dataflowRefType = dataWhere.Dataflow[0].GetTypedRef<DataflowRefType>();
string dataFlowAgency = dataflowRefType.agencyID;
string dataFlowId = dataflowRefType.id;
string dataFlowVersion = null; // null if not specified so as to get the latest
if (dataflowRefType.version != null)
{
dataFlowVersion = dataflowRefType.version;
}
IMaintainableRefObject flowRef = new MaintainableRefObjectImpl(dataFlowAgency, dataFlowId, dataFlowVersion);
dataFlow = structureRetrievalManager.GetMaintainableObject<IDataflowObject>(flowRef);
if (dataFlow == null)
{
throw new SdmxNoResultsException("Dataflow not found: " + flowRef);
}
}
else
{
throw new ArgumentException("Can not create DataQuery, Dataflow is required");
}
return dataFlow;
}
/// <summary>
/// Builds a data provider bean from DataProviderReferenceType from XML
/// </summary>
/// <param name="dataProviderRef">
/// The data provider reference.
/// </param>
/// <param name="structureRetrievalManager">
/// The structure retrieval manager.
/// </param>
/// <returns>
/// The data provider.
/// </returns>
private IDataProvider ProcessDataProviderType(DataProviderReferenceType dataProviderRef, ISdmxObjectRetrievalManager structureRetrievalManager)
{
var dataProviderRefType = dataProviderRef.GetTypedRef<DataProviderRefType>();
string agencyId = dataProviderRefType.agencyID;
string id = dataProviderRefType.maintainableParentID;
string version = dataProviderRefType.maintainableParentVersion;
IMaintainableRefObject orgSchemeRef = new MaintainableRefObjectImpl(agencyId, id, version);
IDataProviderScheme dataProviderScheme = structureRetrievalManager.GetMaintainableObject<IDataProviderScheme>(orgSchemeRef);
foreach (IDataProvider dp in dataProviderScheme.Items)
{
if (dp.Id.Equals(dataProviderRefType.id))
{
return dp;
}
}
return null;
}
/// <summary>
/// Builds a data query from <paramref name="dataWhereType"/>
/// </summary>
/// <param name="dataWhereType">
/// The data Where Type.
/// </param>
/// <param name="structureRetrievalManager">
/// The structure Retrieval Manager.
/// </param>
/// <returns>
/// The <see cref="IDataQuery"/>.
/// </returns>
public IDataQuery BuildDataQuery(
DataWhereType dataWhereType, ISdmxObjectRetrievalManager structureRetrievalManager)
{
if (structureRetrievalManager == null)
{
throw new ArgumentNullException("structureRetrievalManager");
}
this.ProcessDataWhere(dataWhereType);
this.ProcessAnd(dataWhereType.And);
IMaintainableRefObject flowRef = new MaintainableRefObjectImpl(
this._agencyId, this._dataflowId, this._version);
IDataflowObject dataflow = structureRetrievalManager.GetMaintainableObject<IDataflowObject>(flowRef);
if (dataflow == null)
{
throw new SdmxNoResultsException("Dataflow not found: " + flowRef);
}
IMaintainableRefObject dsdRef = dataflow.DataStructureRef.MaintainableReference;
IDataStructureObject dataStructureBean = structureRetrievalManager.GetMaintainableObject<IDataStructureObject>(dsdRef);
if (dataStructureBean == null)
{
throw new SdmxNoResultsException("Data Structure not found: " + dsdRef);
}
// TODO check if DSD is v2.0 compatible
if (!dataStructureBean.IsCompatible(SdmxSchema.GetFromEnum(SdmxSchemaEnumType.VersionTwo)))
{
throw new SdmxSemmanticException("DataStructure used for this dataflow is not SDMX v2.0 compatible.");
}
var convertedDataQuerySelectionGroups = ConvertConceptIdToComponentId(this._dataQuerySelectionGroups, dataStructureBean);
// FUNC Data Provider
return new DataQueryImpl(
dataStructureBean,
null,
null,
this._defaultLimit /* was null TODO */,
true,
null,
dataflow,
null,
convertedDataQuerySelectionGroups);
}