/// <summary>
/// Retrieves all available dataflows.
/// </summary>
private IComplexStructureQuery RetrieveDataflows()
{
var dataflowRefBean = new StructureReferenceImpl(SdmxStructureType.GetFromEnum(SdmxStructureEnumType.Dataflow));
IRestStructureQuery structureQueryDataflow = new RESTStructureQueryCore(dataflowRefBean);
IBuilder <IComplexStructureQuery, IRestStructureQuery> transformerDataFlow = new StructureQuery2ComplexQueryBuilder();
IComplexStructureQuery complexStructureQueryDataflow = transformerDataFlow.Build(structureQueryDataflow);
IList <SdmxStructureType> specificObjects = new List <SdmxStructureType>();
specificObjects.Add(SdmxStructureType.GetFromEnum(SdmxStructureEnumType.Dsd));
IComplexStructureQueryMetadata complexStructureQueryMetadataWithDsd =
new ComplexStructureQueryMetadataCore(false,
ComplexStructureQueryDetail.GetFromEnum(ComplexStructureQueryDetailEnumType.Full),
ComplexMaintainableQueryDetail.GetFromEnum(ComplexMaintainableQueryDetailEnumType.Full),
StructureReferenceDetail.GetFromEnum(StructureReferenceDetailEnumType.Specific),
specificObjects);
IComplexStructureQuery complexStructureQueryTempDataflow = new ComplexStructureQueryCore(
complexStructureQueryDataflow.StructureReference, complexStructureQueryMetadataWithDsd);
return(complexStructureQueryTempDataflow);
}
/// <summary>
/// Retrieves all available categorisations and category schemes.
/// </summary>
private IComplexStructureQuery RetrieveCategorySchemesAndCategorisations()
{
var catSch = new StructureReferenceImpl(SdmxStructureType.GetFromEnum(SdmxStructureEnumType.CategoryScheme));
IRestStructureQuery structureQueryCategoryScheme = new RESTStructureQueryCore(StructureQueryDetail.GetFromEnum(StructureQueryDetailEnumType.Full), StructureReferenceDetail.GetFromEnum(StructureReferenceDetailEnumType.Parents), null, catSch, false);
IBuilder <IComplexStructureQuery, IRestStructureQuery> transformerCategoryScheme = new StructureQuery2ComplexQueryBuilder();
IComplexStructureQuery complexStructureQueryCategoryScheme = transformerCategoryScheme.Build(structureQueryCategoryScheme);
return(complexStructureQueryCategoryScheme);
}
/// <summary>
/// Retrieves all available dataflows.
/// </summary>
/// <returns>
/// The <see cref="string"/>.
/// </returns>
private string RetrieveDataflows()
{
var dataflowRefBean = new StructureReferenceImpl(SdmxStructureType.GetFromEnum(SdmxStructureEnumType.Dataflow));
IRestStructureQuery structureQuery = new RESTStructureQueryCore(StructureQueryDetail.GetFromEnum(StructureQueryDetailEnumType.Full), StructureReferenceDetail.GetFromEnum(StructureReferenceDetailEnumType.Specific), SdmxStructureType.GetFromEnum(SdmxStructureEnumType.Dsd), dataflowRefBean, true);
IStructureQueryFactory factory = new RestStructureQueryFactory();
IStructureQueryBuilderManager structureQueryBuilderManager = new StructureQueryBuilderManager(factory);
IStructureQueryFormat <string> structureQueryFormat = new RestQueryFormat();
string request = structureQueryBuilderManager.BuildStructureQuery(structureQuery, structureQueryFormat);
return(request);
}
/// <summary>
/// Retrieves all available categorisations and category schemes.
/// </summary>
/// <returns>
/// The <see cref="string"/>.
/// </returns>
private string RetrieveCategorySchemesAndCategorisations()
{
var catSch = new StructureReferenceImpl(SdmxStructureType.GetFromEnum(SdmxStructureEnumType.CategoryScheme));
IStructureQueryFormat <string> structureQueryFormat = new RestQueryFormat();
IRestStructureQuery structureQueryCategoryScheme = new RESTStructureQueryCore(StructureQueryDetail.GetFromEnum(StructureQueryDetailEnumType.Full), StructureReferenceDetail.GetFromEnum(StructureReferenceDetailEnumType.Parents), null, catSch, false);
IStructureQueryFactory factory = new RestStructureQueryFactory();
IStructureQueryBuilderManager structureQueryBuilderManager = new StructureQueryBuilderManager(factory);
string request = structureQueryBuilderManager.BuildStructureQuery(structureQueryCategoryScheme, structureQueryFormat);
return(request);
}
/// <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
}
}
private string RetrieveDataflow(string id, string agency, string version)
{
IMaintainableRefObject df = new MaintainableRefObjectImpl(agency, id, version);
var dataflowRefBean = new StructureReferenceImpl(df, SdmxStructureType.GetFromEnum(SdmxStructureEnumType.Dataflow));
IRestStructureQuery structureQuery = new RESTStructureQueryCore(StructureQueryDetail.GetFromEnum(StructureQueryDetailEnumType.Full), StructureReferenceDetail.GetFromEnum(StructureReferenceDetailEnumType.Specific), SdmxStructureType.GetFromEnum(SdmxStructureEnumType.Dsd), dataflowRefBean, true);
IStructureQueryFactory factory = new RestStructureQueryFactory();
IStructureQueryBuilderManager structureQueryBuilderManager = new StructureQueryBuilderManager(factory);
IStructureQueryFormat <string> structureQueryFormat = new RestQueryFormat();
string request = structureQueryBuilderManager.BuildStructureQuery(structureQuery, structureQueryFormat);
return(request);
}
/// <summary>
///
/// </summary>
/// <param name="artefact"></param>
/// <param name="sysId"></param>
private void PopulateConstraintGeneral(IContentConstraintMutableObject artefact, long sysId)
{
var inParameter = MappingStoreDb.CreateInParameter(ParameterNameConstants.IdParameter, DbType.Int64, sysId);
using (DbCommand command = MappingStoreDb.GetSqlStringCommandParam(ContentConstraintConstant.SqlConsInfo, inParameter))
{
using (IDataReader dataReader = this.MappingStoreDb.ExecuteReader(command))
{
bool bGeneral = true;
artefact.ReleaseCalendar = new ReleaseCalendarMutableCore();
artefact.ConstraintAttachment = new ContentConstraintAttachmentMutableCore();
while (dataReader.Read())
{
if (bGeneral)
{
if (dataReader["PERIODICITY"] != DBNull.Value)
{
artefact.ReleaseCalendar.Periodicity = dataReader["PERIODICITY"].ToString();
}
if (dataReader["OFFSET"] != DBNull.Value)
{
artefact.ReleaseCalendar.Offset = dataReader["OFFSET"].ToString();
}
if (dataReader["TOLERANCE"] != DBNull.Value)
{
artefact.ReleaseCalendar.Tolerance = dataReader["TOLERANCE"].ToString();
}
if (String.IsNullOrEmpty(artefact.ReleaseCalendar.Periodicity))
{
artefact.ReleaseCalendar = null;
}
bGeneral = false;
}
IStructureReference structRef = new StructureReferenceImpl(dataReader["AGENCY"].ToString(),
dataReader["ID"].ToString(), dataReader["VERSION"].ToString(),
SdmxStructureType.GetFromEnum((SdmxStructureEnumType)Enum.Parse(typeof(SdmxStructureEnumType), dataReader["ARTEFACT_TYPE"].ToString())),
new string[] { });
artefact.ConstraintAttachment.AddStructureReference(structRef);
}
}
}
}
/// <summary>
/// Build concept scheme requests from the concept scheme references of the specified KeyFamilyBean object
/// </summary>
/// <param name="kf">
/// The KeyFamily to look for concept Scheme references
/// </param>
/// <returns>
/// A list of concept scheme requests
/// </returns>
public static IEnumerable <IStructureReference> BuildConceptSchemeRequest(IDataStructureObject kf)
{
var conceptSchemeSet = new Dictionary <string, object>();
var ret = new List <IStructureReference>();
var crossDsd = kf as ICrossSectionalDataStructureObject;
List <IComponent> components = new List <IComponent>();
components.AddRange(kf.GetDimensions());
components.AddRange(kf.Attributes);
if (kf.PrimaryMeasure != null)
{
components.Add(kf.PrimaryMeasure);
}
if (crossDsd != null)
{
components.AddRange(crossDsd.CrossSectionalMeasures);
}
ICollection <IComponent> comps = components;
foreach (IComponent comp in comps)
{
string key = Utils.MakeKey(comp.ConceptRef.MaintainableReference.MaintainableId, comp.ConceptRef.MaintainableReference.Version, comp.ConceptRef.MaintainableReference.AgencyId);
if (!conceptSchemeSet.ContainsKey(key))
{
// create concept ref
var conceptSchemeRef = new StructureReferenceImpl(SdmxStructureType.GetFromEnum(SdmxStructureEnumType.ConceptScheme))
{
MaintainableId = comp.ConceptRef.MaintainableReference.MaintainableId,
AgencyId = comp.ConceptRef.MaintainableReference.AgencyId,
Version = comp.ConceptRef.MaintainableReference.Version
};
// add it to request
ret.Add(conceptSchemeRef);
// added it to set of visited concept schemes
conceptSchemeSet.Add(key, null);
}
}
return(ret);
}
/// <summary>
/// Gets a bean with data about the key family for specified dataflow.
/// </summary>
/// <param name="dataflow">
/// The dataflow
/// </param>
/// <returns>
/// a <c>StructureBean</c> instance with requested data; the result is never <c>null</c> or incomplete, instead an exception is throwed away if something goes wrong and not all required data is successfully retrieved
/// </returns>
/// <remarks>
/// The resulted bean will contain exactly one key family, but also will include any concepts and codelists referenced by the key family.
/// </remarks>
public ISdmxObjects GetStructure(IDataflowObject dataflow, ISet <IDataStructureObject> dataStructures, bool resolseRef = false)
{
Logger.InfoFormat(
CultureInfo.InvariantCulture,
Resources.InfoGettingStructureFormat3,
dataflow.AgencyId,
dataflow.Id,
dataflow.Version);
ISdmxObjects structure;
var keyFamilyRefBean = new StructureReferenceImpl(SdmxStructureType.GetFromEnum(SdmxStructureEnumType.Dsd))
{
MaintainableId = dataflow.DataStructureRef.MaintainableReference.MaintainableId,
AgencyId = dataflow.DataStructureRef.MaintainableReference.AgencyId,
Version = dataflow.DataStructureRef.MaintainableReference.Version
};
try
{
ISdmxObjects response;
structure = this.SendQueryStructureRequest(keyFamilyRefBean, false);
NsiClientValidation.CheckifStructureComplete(structure, dataflow);
IEnumerable <IStructureReference> conceptRefs = NsiClientHelper.BuildConceptSchemeRequest(structure.DataStructures.First());
response = this.SendQueryStructureRequest(conceptRefs, false);
structure.Merge(response);
NsiClientValidation.CheckConcepts(structure);
Logger.Info(Resources.InfoSuccess);
}
catch (NsiClientException e)
{
Logger.Error(Resources.ExceptionGettingStructure);
Logger.Error(e.Message, e);
throw;
}
catch (Exception e)
{
Logger.Error(Resources.ExceptionGettingStructure);
Logger.Error(e.Message, e);
throw new NsiClientException(Resources.ExceptionGettingStructure, e);
}
return(structure);
}
/// <summary>
/// Retrieves all available categorisations.
/// </summary>
/// <returns>
/// a list of &lt;c&gt;ISdmxObjects&lt;/c&gt; instances; the result won&apos;t be &lt;c&gt;null&lt;/c&gt; if there are no
/// dataflows, instead an empty list will be returned
/// </returns>
public ISdmxObjects RetrieveCategorisations()
{
Logger.Info(Resources.InfoGettingCategorySchemes);
ISdmxObjects response = new SdmxObjectsImpl();
//get dataflows
var dataflowRefBean = new StructureReferenceImpl(SdmxStructureType.GetFromEnum(SdmxStructureEnumType.Dataflow));
//get category scheme
var catSch = new StructureReferenceImpl(SdmxStructureType.GetFromEnum(SdmxStructureEnumType.CategoryScheme));
IList <IStructureReference> refs = new List <IStructureReference>();
refs.Add(catSch);
refs.Add(dataflowRefBean);
try
{
response = this.SendQueryStructureRequest(refs, false);
if (response.CategorySchemes != null && response.Dataflows != null)
{
Logger.Info(Resources.InfoSuccess);
}
}
catch (NsiClientException e)
{
Logger.Error(Resources.ExceptionGettingDataflow);
Logger.Error(e.Message, e);
throw;
}
catch (DataflowException e)
{
throw;
}
catch (Exception e)
{
Logger.Error(Resources.ExceptionGettingDataflow);
Logger.Error(e.Message, e);
throw new NsiClientException(Resources.ExceptionGettingDataflow, e);
}
if (response.Dataflows != null && response.Dataflows.Count == 0)
{
throw new DataflowException(Resources.NoResultsFound);
}
return(response);
}
/// <summary>
/// Gets a bean with data about the codelist for specified dataflow and component.
/// The dataflow can be retrieved from <see cref="RetrieveTree"/> and the component from <see cref="GetStructure"/>
/// </summary>
/// <param name="dataflow">
/// The dataflow
/// </param>
/// <param name="component">
/// The component
/// </param>
/// <param name="criteria">
/// The criteria includes a set of Member and MemberValue(s) for each dimension. The Member has componentRef the dimension conceptRef and the MemberValue(s) specify the selected codes for this dimension.
/// </param>
/// <returns>
/// A <c>CodeListBean</c> with the requested data
/// </returns>
public ICodelistObject GetCodelist(
IDataflowObject dataflow,
IDataStructureObject dsd,
IComponent component,
List <IContentConstraintMutableObject> criterias,
bool Constrained)
{
var codelistRef = new StructureReferenceImpl(SdmxStructureType.GetFromEnum(SdmxStructureEnumType.CodeList));
var dimension = component as IDimension;
if (dimension != null && dimension.TimeDimension)
{
codelistRef.MaintainableId = CustomCodelistConstants.TimePeriodCodeList;
codelistRef.AgencyId = CustomCodelistConstants.Agency;
codelistRef.Version = CustomCodelistConstants.Version;
}
else if (dimension != null && dimension.MeasureDimension && dsd is ICrossSectionalDataStructureObject)
{
var crossDsd = dsd as ICrossSectionalDataStructureObject;
codelistRef.MaintainableId = crossDsd.GetCodelistForMeasureDimension(dimension.Id).MaintainableReference.MaintainableId;
codelistRef.AgencyId = crossDsd.GetCodelistForMeasureDimension(dimension.Id).MaintainableReference.AgencyId;
codelistRef.Version = crossDsd.GetCodelistForMeasureDimension(dimension.Id).MaintainableReference.Version;
}
else
{
if (component.HasCodedRepresentation())
{
codelistRef.MaintainableId = component.Representation.Representation.MaintainableReference.MaintainableId;
codelistRef.AgencyId = component.Representation.Representation.MaintainableReference.AgencyId;
codelistRef.Version = component.Representation.Representation.MaintainableReference.Version;
}
}
string info = string.Format(
CultureInfo.InvariantCulture,
Resources.InfoPartialCodelistFormat3,
Utils.MakeKey(dataflow),
component.ConceptRef,
Utils.MakeKey(codelistRef));
return(this.GetCodelist(dataflow, codelistRef, criterias, info, Constrained));
}
/// <summary>
/// Get the maximum number of observations that can be retrieved given the specified criteria
/// </summary>
/// <param name="dataflow">
/// The dataflow
/// </param>
/// <param name="criteria">
/// The criteria includes a set of Member and MemberValue(s) for each dimension. Each member should have member values else they shouldn't be included. It can be null
/// </param>
/// <returns>
/// The maximum number of observations or -1 if it can't be parsed or it is not available
/// </returns>
/// <exception cref="NsiClientException">
/// NSI WS communication error or parsing error
/// </exception>
public int GetDataflowDataCount(IDataflowObject dataflow, IContentConstraintMutableObject criteria)
{
int count;
List <IContentConstraintMutableObject> criterias = new List <IContentConstraintMutableObject>();
if (criteria == null)
{
criteria = new ContentConstraintMutableCore();
}
criteria.Id = CustomCodelistConstants.CountCodeList;
criteria.AddName("en", "name");
criteria.AgencyId = "agency";
criterias.Add(criteria);
var codelistRef = new StructureReferenceImpl(SdmxStructureType.GetFromEnum(SdmxStructureEnumType.CodeList))
{
MaintainableId = CustomCodelistConstants.CountCodeList,
AgencyId = CustomCodelistConstants.Agency,
Version = CustomCodelistConstants.Version
};
string info = string.Format(CultureInfo.InvariantCulture, Resources.InfoCountFormat2, Utils.MakeKey(dataflow), Utils.MakeKey(codelistRef));
try
{
ICodelistObject countCodelist = this.GetCodelist(dataflow, codelistRef, criterias, info, true);
if (!CustomCodelistConstants.IsCountCodeList(countCodelist) ||
!int.TryParse(countCodelist.Items[0].Id, out count))
{
Logger.WarnFormat(CultureInfo.InvariantCulture, Resources.ExceptionParsingCountCodelistFormat0, info);
throw new NsiClientException("Error parsing the count codelist for " + info);
}
}
catch (NsiClientException ex)
{
Logger.Warn(ex.Message, ex);
count = -1;
}
return(count);
}
/// <summary>
/// Generic method for retrieving <see cref="IStructureReference"/> based objects
/// </summary>
/// <param name="outList">
/// The output list
/// </param>
/// <param name="command">
/// The current <see cref="DbCommand"/>
/// </param>
/// <param name="structureType">
/// The structure Type.
/// </param>
protected void RetrieveRef(ICollection <IStructureReference> outList, DbCommand command, SdmxStructureEnumType structureType)
{
_log.DebugFormat("RetrieveRef of {0} SQL : {1}", structureType, command.CommandText);
using (IDataReader dataReader = this._mappingStoreDb.ExecuteReader(command))
{
int idField = dataReader.GetOrdinal("ID");
int agencyField = dataReader.GetOrdinal("AGENCY");
int versionField = dataReader.GetOrdinal("VERSION");
while (dataReader.Read())
{
var item = new StructureReferenceImpl(SdmxStructureType.GetFromEnum(structureType))
{
MaintainableId = DataReaderHelper.GetString(dataReader, idField),
Version = DataReaderHelper.GetString(dataReader, versionField),
AgencyId = DataReaderHelper.GetString(dataReader, agencyField)
};
outList.Add(item);
}
}
}
/// <summary>
/// Returns the referenced from inner joins to use with <see cref="ArtefactParentsSqlBuilder"/>
/// </summary>
/// <param name="structureEnumType">
/// The structure type.
/// </param>
/// <returns>
/// The referenced from inner joins
/// </returns>
protected override string GetReferencedFromInnerJoins(SdmxStructureEnumType structureEnumType)
{
string innerJoin = null;
switch (structureEnumType)
{
case SdmxStructureEnumType.Category:
case SdmxStructureEnumType.CategoryScheme:
innerJoin = CategorySchemeConstant.ReferencedByCategorisation;
break;
default:
if (SdmxStructureType.GetFromEnum(structureEnumType).IsMaintainable)
{
innerJoin = CategorisationConstant.ReferencedByCategorisation;
}
break;
}
return(innerJoin);
}
/// <summary>
/// Gets a bean with data about the codelist for specified dataflow and codelist ref.
/// The dataflow can be retrieved from <see cref="RetrieveDataflow"/>
/// </summary>
/// <param name="dataflow">
/// The dataflow
/// </param>
/// <param name="codelistRef">
/// The codelist reference
/// </param>
/// <param name="criteria">
/// The criteria includes a set of Member and MemberValue(s) for each dimension.
/// </param>
/// <param name="info">
/// Some helper information used for logging
/// </param>
/// <returns>
/// The partial codelist.
/// </returns>
private ICodelistObject GetCodelist(
IDataflowObject dataflow,
IStructureReference codelistRef,
List <IContentConstraintMutableObject> criterias,
string info,
bool Constrained)
{
ICodelistObject codelist;
var refs = new List <IStructureReference>();
refs.Add(codelistRef);
if (Constrained)
{
var dataflowRef = new StructureReferenceImpl(SdmxStructureType.GetFromEnum(SdmxStructureEnumType.Dataflow))
{
MaintainableId = dataflow.Id,
AgencyId = dataflow.AgencyId,
Version = dataflow.Version,
};
foreach (var criteria in criterias)
{
var dataflowRefBean = new ConstrainableStructureReference(dataflowRef, criteria.ImmutableInstance);
Logger.InfoFormat(CultureInfo.InvariantCulture, Resources.InfoGettingCodelistFormat1, info);
refs.Add(dataflowRefBean);
}
}
try
{
ISdmxObjects response;
response = this.SendQueryStructureRequest(refs, false);
if (response.Codelists.Count != 1)
{
string message = string.Format(
CultureInfo.InvariantCulture, Resources.ExceptionInvalidNumberOfCodeListsFormat1, info);
Logger.Error(message);
throw new NsiClientException(message);
}
codelist = response.Codelists.First();
if (codelist.Items.Count == 0)
{
string message = string.Format(
CultureInfo.InvariantCulture, Resources.ExceptionZeroCodesFormat1, info);
Logger.Error(message);
throw new NsiClientException(message);
}
}
catch (NsiClientException e)
{
string message = string.Format(
CultureInfo.InvariantCulture, Resources.ExceptionGetCodelistFormat2, info, e.Message);
Logger.Error(message);
Logger.Error(e.Message, e);
throw;
}
catch (DataflowException e)
{
throw;
}
catch (Exception e)
{
string message = string.Format(
CultureInfo.InvariantCulture, Resources.ExceptionGetCodelistFormat2, info, e.Message);
Logger.Error(message);
Logger.Error(e.Message, e);
throw new NsiClientException(message, e);
}
return(codelist);
}
public ISdmxObjects GetStructure(string DataflowId, string DatafloAgency, string DatafloVersion, bool resolseRef = false)
{
Logger.InfoFormat(
CultureInfo.InvariantCulture,
Resources.InfoGettingStructureFormat3,
DatafloAgency,
DataflowId,
DatafloVersion);
#region Dataflow
ISdmxObjects responseDF = new SdmxObjectsImpl();
var dataflowRefBean = new StructureReferenceImpl(SdmxStructureType.GetFromEnum(SdmxStructureEnumType.Dataflow))
{
MaintainableId = DataflowId,
AgencyId = DatafloAgency,
Version = DatafloVersion
};
IList <IStructureReference> refs = new List <IStructureReference>();
refs.Add(dataflowRefBean);
responseDF = this.SendQueryStructureRequest(refs, false);
if (responseDF.Dataflows == null || responseDF.Dataflows.Count == 0)
{
throw new Exception("Dataflow not found");
}
#endregion
IDataflowObject dataflow = responseDF.Dataflows.First();
ISdmxObjects structure;
var keyFamilyRefBean = new StructureReferenceImpl(SdmxStructureType.GetFromEnum(SdmxStructureEnumType.Dsd))
{
MaintainableId = dataflow.DataStructureRef.MaintainableReference.MaintainableId,
AgencyId = dataflow.DataStructureRef.MaintainableReference.AgencyId,
Version = dataflow.DataStructureRef.MaintainableReference.Version
};
try
{
ISdmxObjects response;
structure = this.SendQueryStructureRequest(keyFamilyRefBean, resolseRef);
NsiClientValidation.CheckifStructureComplete(structure, dataflow);
IEnumerable <IStructureReference> conceptRefs = NsiClientHelper.BuildConceptSchemeRequest(structure.DataStructures.First());
response = this.SendQueryStructureRequest(conceptRefs, resolseRef);
structure.Merge(responseDF);
structure.Merge(response);
NsiClientValidation.CheckConcepts(structure);
Logger.Info(Resources.InfoSuccess);
}
catch (NsiClientException e)
{
Logger.Error(Resources.ExceptionGettingStructure);
Logger.Error(e.Message, e);
throw;
}
catch (Exception e)
{
Logger.Error(Resources.ExceptionGettingStructure);
Logger.Error(e.Message, e);
throw new NsiClientException(Resources.ExceptionGettingStructure, e);
}
return(structure);
}
private DataStructureObjectImpl BuildDataStructure(string _foundedDataflowId)
{
try
{
string ConceptSchemeId = string.Format(FlyConfiguration.ConceptSchemeFormat, _foundedDataflowId);
List <IComponentMutableObject> components = new List <IComponentMutableObject>();
if (!this.ReferencesObject.Concepts.ContainsKey(ConceptSchemeId))
{
ConceptSchemeManager gdf = new ConceptSchemeManager((ISdmxParsingObject)this.parsingObject.Clone(), this.versionTypeResp);
ReferencesObject.Concepts.Add(string.Format(FlyConfiguration.ConceptSchemeFormat, _foundedDataflowId), gdf.GetConceptList(_foundedDataflowId));
}
if (!this.ReferencesObject.Concepts.ContainsKey(ConceptSchemeId))
{
throw new Exception("ConceptScheme not found");
}
List <IConceptObjectImpl> conceptsObject = this.ReferencesObject.Concepts[ConceptSchemeId];
if (!this.parsingObject.ReturnStub)
{
foreach (IConceptObjectImpl _concept in conceptsObject)
{
//Cerco la giusta Codelist
ICodelistMutableObject _CodelistAssociata = null;
if (this.ReferencesObject.Codelists != null)
{
_CodelistAssociata = this.ReferencesObject.Codelists.Find(cl => cl.Id.ToUpper() == _concept.CodelistCode);
}
// CodelistBuilder _CodelistAssociata = this._Codelists.Find(cl => cl.Concept.ConceptObjectCode == _concept.ConceptObjectCode);
//Capire se è un attribute/Dimension
if (_CodelistAssociata == null)
{
CodelistManager cm = new CodelistManager((ISdmxParsingObject)this.parsingObject.Clone(), this.versionTypeResp);
if (!String.IsNullOrEmpty(_concept.CodelistCode))
{
cm.parsingObject.MaintainableId = string.Format(FlyConfiguration.CodelistFormat, _concept.CodelistCode.Substring(3));
}
else
{
cm.parsingObject.MaintainableId = null;
}
cm.parsingObject.QueryDetail = StructureQueryDetailEnumType.AllStubs;
cm.BuildCodelist(_foundedDataflowId, _concept);
if (cm.ReferencesObject.Codelists != null && cm.ReferencesObject.Codelists.Count > 0)
{
_CodelistAssociata = cm.ReferencesObject.Codelists[0];
}
}
if (_CodelistAssociata != null)
{
_concept.ConceptDSDInfo = new ConceptDSDInfoObject()
{
CodelistId = _CodelistAssociata.Id,
CodelistAgency = _CodelistAssociata.AgencyId,
CodelistVersion = _CodelistAssociata.Version
};
}
switch (_concept.ConceptType)
{
case ConceptTypeEnum.Dimension:
//Se è una Dimension Capire che tipologia di Dimension è Frequency/Time
switch (((IDimensionConcept)_concept).DimensionType)
{
case DimensionTypeEnum.Dimension:
DimensionMutableCore dim = new DimensionMutableCore();
dim.ConceptRef = ReferenceBuilder.CreateConceptReference(ConceptSchemeId, _concept.Id);
dim.Id = _concept.Id;
if (_CodelistAssociata != null)
{
dim.Representation = new RepresentationMutableCore()
{
Representation = ReferenceBuilder.CreateCodelistReference(_CodelistAssociata.Id),
};
}
components.Add(dim);
break;
case DimensionTypeEnum.Time:
DimensionMutableCore TimeDim = new DimensionMutableCore();
TimeDim.ConceptRef = ReferenceBuilder.CreateConceptReference(ConceptSchemeId, _concept.ConceptObjectCode);
TimeDim.Id = _concept.ConceptObjectCode;
TimeDim.TimeDimension = true;
components.Add(TimeDim);
break;
case DimensionTypeEnum.Frequency:
DimensionMutableCore FreqDim = new DimensionMutableCore();
FreqDim.ConceptRef = ReferenceBuilder.CreateConceptReference(ConceptSchemeId, _concept.ConceptObjectCode);
if (_CodelistAssociata != null)
{
FreqDim.Representation = new RepresentationMutableCore()
{ ////Si da per scontato che la frequency la codelist ce l'abbia
Representation = ReferenceBuilder.CreateCodelistReference(_CodelistAssociata.Id),
};
}
FreqDim.Id = _concept.ConceptObjectCode;
FreqDim.FrequencyDimension = true;
if (FreqDim.ConceptRole != null)
{
FreqDim.ConceptRole.Add(new StructureReferenceImpl("ESTAT", "ESTAT_CONCEPT_ROLES_SCHEME", "0.1", SdmxStructureType.GetFromEnum(SdmxStructureEnumType.Concept), new List <string> {
"FREQUENCY"
}));
}
components.Add(FreqDim);
break;
default:
break;
}
break;
case ConceptTypeEnum.Attribute:
AttributeMutableCore attr = new AttributeMutableCore();
attr.ConceptRef = ReferenceBuilder.CreateConceptReference(ConceptSchemeId, _concept.ConceptObjectCode);
if (_CodelistAssociata != null)
{
IRepresentationMutableObject representation = new RepresentationMutableCore();
representation.Representation = ReferenceBuilder.CreateCodelistReference(_CodelistAssociata.Id);
attr.Representation = representation;
}
//Aggiungo attributi all'attribute AssignmentStatus e AttachmentLevel
attr.AssignmentStatus = ((IAttributeConcept)_concept).AssignmentStatusType.ToString();
attr.AttachmentLevel = ((IAttributeConcept)_concept).AttributeAttachmentLevelType;
if (attr.AttachmentLevel == AttributeAttachmentLevel.DimensionGroup)
{
foreach (var dimref in ((IAttributeConcept)_concept).GetDimensionsReference(ReferencesObject.Concepts[ConceptSchemeId]))
{
attr.DimensionReferences.Add(dimref);
}
}
if (attr.AttachmentLevel == AttributeAttachmentLevel.Group)
{
throw new SdmxException(this, FlyExceptionObject.FlyExceptionTypeEnum.AttributeErrorAttachmentGroup);
}
//if (_CodelistAssociata.CodesObjects == null || _CodelistAssociata.CodesObjects.Count == 0)
//{//levo dall'attribute la referenza alla codelist
// attr.Representation = null;
//}
if (((IAttributeConcept)_concept).IsValueAttribute)
{
PrimaryMeasureMutableCore PrimaryMeasure = new PrimaryMeasureMutableCore(); //SdmxStructureType.GetFromEnum(SdmxStructureEnumType.PrimaryMeasure));
PrimaryMeasure.ConceptRef = ReferenceBuilder.CreateConceptReference(ConceptSchemeId, _concept.ConceptObjectCode);
components.Add(PrimaryMeasure);
}
else
{
components.Add(attr);
}
break;
}
}
}
this.ReferencesObject.Codelists = null;
DataStructureBuilder _DataStructureBuilder = new DataStructureBuilder(conceptsObject, this.parsingObject, this.versionTypeResp);
_DataStructureBuilder.Code = string.Format(FlyConfiguration.DsdFormat, _foundedDataflowId);
_DataStructureBuilder.Names = new List <SdmxObjectNameDescription>();
foreach (var nome in ReferencesObject.FoundedDataflows.Find(df => df.Id == _foundedDataflowId).Names)
{
_DataStructureBuilder.Names.Add(new SdmxObjectNameDescription()
{
Lingua = nome.Locale, Name = nome.Value
});
}
return(_DataStructureBuilder.BuildDataStructure(components, null, FlyConfiguration.MainAgencyId, FlyConfiguration.Version));
}
catch (SdmxException) { throw; }
catch (Exception ex)
{
throw new SdmxException(this, FlyExceptionObject.FlyExceptionTypeEnum.CreateImmutable, ex);
}
}
/// <summary>
/// Check if the specified <paramref name="structureEnumType"/> is in <paramref name="sdmxStructureTypes"/>.
/// </summary>
/// <param name="sdmxStructureTypes">
/// The SDMX structure types.
/// </param>
/// <param name="structureEnumType">
/// The structure type as an ENUM.
/// </param>
/// <returns>
/// True if <paramref name="structureEnumType"/> is in <paramref name="sdmxStructureTypes"/> or if <paramref name="sdmxStructureTypes"/> is empty; otherwise false.
/// </returns>
public static bool HasStructure(this ISet <SdmxStructureType> sdmxStructureTypes, SdmxStructureEnumType structureEnumType)
{
return(sdmxStructureTypes.Count == 0 || sdmxStructureTypes.Contains(SdmxStructureType.GetFromEnum(structureEnumType)));
}