/// <summary>
/// Retrieve the structures referenced by <paramref name="queries"/> and populate the
/// <paramref name="mutableObjects"/>
/// </summary>
/// <param name="retrievalManager">
/// The retrieval manager.
/// </param>
/// <param name="mutableObjects">
/// The mutable objects.
/// </param>
/// <param name="queries">
/// The queries.
/// </param>
/// <param name="returnLatest">
/// The return Latest.
/// </param>
/// <param name="returnStub">
/// The return Stub.
/// </param>
/// <param name="allowedDataflows">
/// The allowed Dataflows.
/// </param>
/// <param name="crossReferenceMutableRetrievalManager">
/// The cross reference mutable retrieval manager.
/// </param>
protected virtual void PopulateMutables(IAuthAdvancedSdmxMutableObjectRetrievalManager retrievalManager, IMutableObjects mutableObjects, IList<IStructureReference> queries, bool returnLatest, StructureQueryDetailEnumType returnStub, IList<IMaintainableRefObject> allowedDataflows, IAuthCrossReferenceMutableRetrievalManager crossReferenceMutableRetrievalManager)
{
//// changes here might also apply to AuthAdvancedMutableStructureSearchManagerBase
for (int i = 0; i < queries.Count; i++)
{
var structureReference = queries[i];
IRestStructureQuery restStructureQuery = new RESTStructureQueryCore(StructureQueryDetail.GetFromEnum(returnStub), StructureReferenceDetail.GetFromEnum(StructureReferenceDetailEnumType.None), null, structureReference, returnLatest);
var complexStructureQuery = _complexQueryBuilder.Build(restStructureQuery);
base.PopulateMutables(retrievalManager, mutableObjects, complexStructureQuery, allowedDataflows, crossReferenceMutableRetrievalManager);
}
}
/// <summary>
/// Retrieve the <paramref name="queries"/> and populate the <paramref name="mutableObjects"/>
/// </summary>
/// <param name="retrievalManager">
/// The retrieval manager.
/// </param>
/// <param name="mutableObjects">
/// The mutable objects.
/// </param>
/// <param name="queries">
/// The structure queries
/// </param>
/// <param name="returnLatest">
/// Set to <c>true</c> to retrieve the latest; otherwise set to <c>false</c> to retrieve all versions
/// </param>
/// <param name="returnStub">
/// Set to <c>true</c> to retrieve artefacts as stubs; otherwise set to <c>false</c> to retrieve full artefacts.
/// </param>
/// <param name="allowedDataflows">
/// The allowed dataflows.
/// </param>
/// <param name="crossReferenceMutableRetrievalManager">
/// The cross-reference manager
/// </param>
protected override void PopulateMutables(IAuthAdvancedSdmxMutableObjectRetrievalManager retrievalManager, IMutableObjects mutableObjects, IList<IStructureReference> queries, bool returnLatest, StructureQueryDetailEnumType returnStub, IList<IMaintainableRefObject> allowedDataflows, IAuthCrossReferenceMutableRetrievalManager crossReferenceMutableRetrievalManager)
{
var dataflowLessQueries = new List<IStructureReference>();
var dataflowQueries = new List<IStructureReference>();
foreach (var query in queries)
{
if (query.MaintainableStructureEnumType.EnumType == SdmxStructureEnumType.Dataflow)
{
dataflowQueries.Add(query);
}
else
{
dataflowLessQueries.Add(query);
}
}
base.PopulateMutables(retrievalManager, mutableObjects, dataflowLessQueries, returnLatest, returnStub, allowedDataflows, crossReferenceMutableRetrievalManager);
// get the latest for dataflows to emulate the intermediate SR behavior.
base.PopulateMutables(retrievalManager, mutableObjects, dataflowQueries, true, returnStub, allowedDataflows, crossReferenceMutableRetrievalManager);
if (queries.NeedsCategorisation())
{
_log.Info("SDMX v2.0 structure search manager used. Trying to retrieve categorisations all dataflows and categorisations.");
IMutableObjects objects = new MutableObjectsImpl(mutableObjects.Dataflows);
objects.AddIdentifiables(mutableObjects.CategorySchemes);
// get categorisations
IResolverFactory factory = new ResolverFactory();
var resolver = factory.GetResolver(StructureReferenceDetail.GetFromEnum(StructureReferenceDetailEnumType.Parents), crossReferenceMutableRetrievalManager);
resolver.ResolveReferences(objects, returnStub == StructureQueryDetailEnumType.AllStubs, allowedDataflows);
// add them to mutable objects
mutableObjects.AddIdentifiables(objects.Categorisations);
}
}
/// <summary>
/// Retrieve the <paramref name="queries"/> and populate the <paramref name="mutableObjects"/>
/// </summary>
/// <param name="retrievalManager">
/// The retrieval manager.
/// </param>
/// <param name="mutableObjects">
/// The mutable objects.
/// </param>
/// <param name="queries">
/// The structure queries
/// </param>
/// <param name="returnLatest">
/// Set to <c>true</c> to retrieve the latest; otherwise set to <c>false</c> to retrieve all versions
/// </param>
/// <param name="returnStub">
/// Set to <c>true</c> to retrieve artefacts as stubs; otherwise set to <c>false</c> to retrieve full artefacts.
/// </param>
/// <param name="allowedDataflows">
/// The allowed dataflows.
/// </param>
/// <param name="crossReferenceMutableRetrievalManager">
/// The cross-reference manager
/// </param>
protected override void PopulateMutables(IAuthAdvancedSdmxMutableObjectRetrievalManager retrievalManager, IMutableObjects mutableObjects, IList<IStructureReference> queries, bool returnLatest, StructureQueryDetailEnumType returnStub, IList<IMaintainableRefObject> allowedDataflows, IAuthCrossReferenceMutableRetrievalManager crossReferenceMutableRetrievalManager)
{
try
{
// try get the codelist reference
IMaintainableRefObject codelistReference =
queries.Where(structureReference => structureReference.TargetReference.EnumType == SdmxStructureEnumType.CodeList)
.Select(structureReference => structureReference.MaintainableReference)
.FirstOrDefault();
// try get the dataflow ref
var dataflowRef = queries.FirstOrDefault(structureReference => structureReference.TargetReference.EnumType == SdmxStructureEnumType.Dataflow) as IConstrainableStructureReference;
// check if it is special
if (codelistReference != null && dataflowRef != null && dataflowRef.ConstraintObject != null && queries.Count == 2)
{
// get the dataflow
base.PopulateMutables(
retrievalManager,
mutableObjects,
new IStructureReference[] { dataflowRef },
returnLatest,
returnStub,
allowedDataflows,
crossReferenceMutableRetrievalManager);
// get the partial codelist
StructureRetrievalInfo structureRetrievalInfo = _structureRetrievalInfoBuilder.Build(dataflowRef, this._connectionStringSettings, allowedDataflows);
if (!ProcessReference(structureRetrievalInfo, codelistReference, mutableObjects))
{
string message = string.Format(CultureInfo.InvariantCulture, "No codes found for {0}", codelistReference);
_logger.Error(message);
throw new SdmxNoResultsException(message);
}
}
else
{
// not special requests
base.PopulateMutables(retrievalManager, mutableObjects, queries, returnLatest, returnStub, allowedDataflows, crossReferenceMutableRetrievalManager);
}
}
catch (SdmxException)
{
throw;
}
catch (StructureRetrieverException e)
{
_logger.Error(e.Message, e);
switch (e.ErrorType)
{
case StructureRetrieverErrorTypes.ParsingError:
throw new SdmxSyntaxException(e, ExceptionCode.XmlParseException);
case StructureRetrieverErrorTypes.MissingStructure:
case StructureRetrieverErrorTypes.MissingStructureRef:
throw new SdmxNoResultsException(e.Message);
default:
throw new SdmxInternalServerException(e.Message);
}
}
catch (DbException e)
{
string mesage = "Mapping Store connection error." + e.Message;
_logger.Error(mesage, e);
throw new SdmxInternalServerException(mesage);
}
catch (Exception e)
{
string mesage = e.Message;
_logger.Error(mesage, e);
throw new SdmxInternalServerException(mesage);
}
}
/// <summary>
/// Retrieve the structures referenced by <paramref name="queries"/> and populate the
/// <paramref name="mutableObjects"/>
/// </summary>
/// <param name="mutableObjects">
/// The mutable objects.
/// </param>
/// <param name="queries">
/// The queries.
/// </param>
/// <param name="returnLatest">
/// The return Latest.
/// </param>
/// <param name="returnStub">
/// The return Stub.
/// </param>
/// <param name="allowedDataflows">
/// The allowed Dataflows.
/// </param>
protected virtual void PopulateMutables(IMutableObjects mutableObjects, IList<IStructureReference> queries, bool returnLatest, StructureQueryDetailEnumType returnStub, IList<IMaintainableRefObject> allowedDataflows)
{
var cachedRetrievalManager = this._advancedMutableRetrievalManagerFactory.GetRetrievalManager(this._retrievalAdvancedManager);
var crossReferenceMutableRetrievalManager = this._crossReferenceManager.GetCrossRetrievalManager(this._database, cachedRetrievalManager);
PopulateMutables(cachedRetrievalManager, mutableObjects, queries, returnLatest, returnStub, allowedDataflows, crossReferenceMutableRetrievalManager);
}
public void TestGetMaintainables(
SdmxStructureEnumType structureEnumType,
StructureQueryDetailEnumType detail,
StructureReferenceDetailEnumType refDetailEnum,
SdmxStructureEnumType specificStructure)
{
var mutableSearchManager = this.GetMutableSearchManager(this._connectionString);
var refDetail = StructureReferenceDetail.GetFromEnum(refDetailEnum);
var sdmxStructureType = SdmxStructureType.GetFromEnum(specificStructure == SdmxStructureEnumType.HierarchicalCodelist && structureEnumType == SdmxStructureEnumType.CodeList ? SdmxStructureEnumType.HierarchicalCodelist : SdmxStructureEnumType.Categorisation);
IStructureReference reference = new StructureReferenceImpl(new MaintainableRefObjectImpl(), sdmxStructureType);
SdmxStructureType structureType = SdmxStructureType.GetFromEnum(structureEnumType);
IRestStructureQuery query = new RESTStructureQueryCore(
StructureQueryDetail.GetFromEnum(StructureQueryDetailEnumType.Full),
StructureReferenceDetail.GetFromEnum(StructureReferenceDetailEnumType.Specific),
structureType,
reference,
false);
var allObjects = mutableSearchManager.GetMaintainables(query).GetMaintainables(structureType);
var referenceLevel = StructureReferenceDetail.GetFromEnum(refDetailEnum);
_log.DebugFormat(CultureInfo.InvariantCulture, "Structure type: {0}, Detail: {1}, Reference : {2}", structureType, detail, refDetail);
foreach (var maintainableMutableObject in allObjects)
{
if ("MA".Equals(maintainableMutableObject.AgencyId))
{
continue;
}
var structureReference = _fromMutable.Build(maintainableMutableObject);
_log.DebugFormat(CultureInfo.InvariantCulture, "Checking maintainable : {0}", structureReference);
var mockQuery = new RESTStructureQueryCore(StructureQueryDetail.GetFromEnum(detail), referenceLevel, SdmxStructureType.GetFromEnum(specificStructure), structureReference, false);
switch (refDetail.EnumType)
{
case StructureReferenceDetailEnumType.Null:
break;
case StructureReferenceDetailEnumType.None:
{
var mutableObject = GetMutables(mutableSearchManager, mockQuery, maintainableMutableObject);
Assert.IsTrue(mutableObject.GetMaintainables(structureType).All(o => o.StructureType.EnumType == structureType.EnumType));
}
break;
case StructureReferenceDetailEnumType.Parents:
{
var mutableObject = GetMutables(mutableSearchManager, mockQuery, maintainableMutableObject);
ValidateParents(mutableObject, structureType, detail != StructureQueryDetailEnumType.Full, structureReference);
}
break;
case StructureReferenceDetailEnumType.ParentsSiblings:
{
var mutableObject = GetMutables(mutableSearchManager, mockQuery, maintainableMutableObject);
ValidateParentsAndSiblings(mutableObject, structureType, detail != StructureQueryDetailEnumType.Full);
}
break;
case StructureReferenceDetailEnumType.Children:
{
var mutableObject = GetMutables(mutableSearchManager, mockQuery, maintainableMutableObject);
ValidateChildren(mutableObject, structureType, detail != StructureQueryDetailEnumType.Full);
}
break;
case StructureReferenceDetailEnumType.Descendants:
{
var mutableObject = GetMutables(mutableSearchManager, mockQuery, maintainableMutableObject);
ValidateDescendants(mutableObject, structureType, detail != StructureQueryDetailEnumType.Full);
}
break;
case StructureReferenceDetailEnumType.All:
{
var mutableObject = GetMutables(mutableSearchManager, mockQuery, maintainableMutableObject);
ValidateAll(mutableObject, structureType, detail != StructureQueryDetailEnumType.Full);
}
break;
case StructureReferenceDetailEnumType.Specific:
{
if (specificStructure != SdmxStructureEnumType.Categorisation || detail == StructureQueryDetailEnumType.Full)
{
var specificStructureReference = SdmxStructureType.GetFromEnum(specificStructure);
var specificQuery = new RESTStructureQueryCore(StructureQueryDetail.GetFromEnum(detail), referenceLevel, specificStructureReference, structureReference, false);
var mutablesWithSpecific = GetMutables(mutableSearchManager, specificQuery, maintainableMutableObject);
ValidateSpecific(mutablesWithSpecific, structureType, detail != StructureQueryDetailEnumType.Full, specificStructureReference, structureReference);
}
}
break;
default:
throw new ArgumentOutOfRangeException();
}
}
}
public void TestGetMaintainablesAuthResult(SdmxStructureEnumType structureEnumType, StructureQueryDetailEnumType detail, StructureReferenceDetailEnumType refDetailEnum)
{
var mutableSearchManager = this.GetAuthMutableSearchManager(this._connectionString);
var refDetail = StructureReferenceDetail.GetFromEnum(refDetailEnum);
var structureType = SdmxStructureType.GetFromEnum(structureEnumType);
IStructureReference reference = new StructureReferenceImpl(new MaintainableRefObjectImpl(), structureType);
switch (structureType.EnumType)
{
case SdmxStructureEnumType.Dataflow:
case SdmxStructureEnumType.Dsd:
var allowedDataflows = (from x in this._fullRetrievalManager.GetMutableDataflowObjects(new MaintainableRefObjectImpl(), false, false) select _fromMutable.Build(x).MaintainableReference).ToArray();
var list = this._fullRetrievalManager.GetMutableMaintainables(reference, false, false);
var queryMetadataMock = new Mock<IStructureQueryMetadata>();
queryMetadataMock.Setup(query => query.IsReturnLatest).Returns(false);
queryMetadataMock.Setup(query => query.SpecificStructureReference).Returns((SdmxStructureType)null);
queryMetadataMock.Setup(query => query.StructureReferenceDetail).Returns(refDetail);
queryMetadataMock.Setup(query => query.StructureQueryDetail).Returns(StructureQueryDetail.GetFromEnum(detail));
var mockQuery = new Mock<IRestStructureQuery>();
mockQuery.Setup(query => query.StructureReference).Returns(reference);
mockQuery.Setup(query => query.StructureQueryMetadata).Returns(() => queryMetadataMock.Object);
_log.DebugFormat(CultureInfo.InvariantCulture, "Structure type: {0}, Detail: {1}, Reference : {2}", structureType, detail, refDetail);
foreach (var maintainableMutableObject in list)
{
switch (refDetail.EnumType)
{
case StructureReferenceDetailEnumType.Null:
break;
case StructureReferenceDetailEnumType.None:
{
var mutableObject = mutableSearchManager.GetMaintainables(mockQuery.Object, allowedDataflows);
Assert.IsNotNull(mutableObject, _fromMutable.Build(maintainableMutableObject).ToString());
Assert.IsNotEmpty(mutableObject.AllMaintainables, _fromMutable.Build(maintainableMutableObject).ToString());
}
break;
case StructureReferenceDetailEnumType.Parents:
{
var mutableObject = mutableSearchManager.GetMaintainables(mockQuery.Object, allowedDataflows);
Assert.IsNotNull(mutableObject, _fromMutable.Build(maintainableMutableObject).ToString());
Assert.IsNotEmpty(mutableObject.AllMaintainables, _fromMutable.Build(maintainableMutableObject).ToString());
}
break;
case StructureReferenceDetailEnumType.ParentsSiblings:
break;
case StructureReferenceDetailEnumType.Children:
{
var mutableObject = mutableSearchManager.GetMaintainables(mockQuery.Object, allowedDataflows);
Assert.IsNotNull(mutableObject, _fromMutable.Build(maintainableMutableObject).ToString());
Assert.IsNotEmpty(mutableObject.AllMaintainables, _fromMutable.Build(maintainableMutableObject).ToString());
}
break;
case StructureReferenceDetailEnumType.Descendants:
break;
case StructureReferenceDetailEnumType.All:
break;
case StructureReferenceDetailEnumType.Specific:
{
queryMetadataMock.Setup(query => query.StructureReferenceDetail).Returns(StructureReferenceDetail.GetFromEnum(StructureReferenceDetailEnumType.None));
var mutableObject = mutableSearchManager.GetMaintainables(mockQuery.Object, allowedDataflows);
queryMetadataMock.Setup(query => query.StructureReferenceDetail).Returns(refDetail);
Assert.IsNotNull(mutableObject, _fromMutable.Build(maintainableMutableObject).ToString());
Assert.IsNotEmpty(mutableObject.AllMaintainables, _fromMutable.Build(maintainableMutableObject).ToString());
}
break;
default:
throw new ArgumentOutOfRangeException();
}
}
break;
}
}
private string GetStructureQueryFormat(IStructureReference dataflowRef, string version,StructureQueryDetailEnumType structureQueryDetail, StructureReferenceDetailEnumType structureReference )
{
IStructureQueryFormat<string> structureQueryFormat = new RestQueryFormat();
IStructureQueryFactory factory = new RestStructureQueryFactory();
IStructureQueryBuilderManager structureQueryBuilderManager = new StructureQueryBuilderManager(factory);
bool returnLatest = version == null;
SdmxStructureType specificStructureReference = structureReference == StructureReferenceDetailEnumType.Specific? SdmxStructureType.GetFromEnum(SdmxStructureEnumType.CodeList) : null;
IRestStructureQuery structureQuery = new RESTStructureQueryCore(StructureQueryDetail.GetFromEnum(structureQueryDetail), StructureReferenceDetail.GetFromEnum(structureReference), specificStructureReference, dataflowRef, returnLatest);
string request = structureQueryBuilderManager.BuildStructureQuery(structureQuery, structureQueryFormat);
return request;
}
public void TestRestStructureQueryIsMaintainable(string agency, string id, string version, StructureQueryDetailEnumType structureQueryDetail, StructureReferenceDetailEnumType structureReferenceDetail)
{
var dataflowRef = new StructureReferenceImpl(SdmxStructureType.GetFromEnum(SdmxStructureEnumType.Dataflow))
{
MaintainableId = id,
AgencyId = agency,
Version = version,
};
bool returnLatest = version == null;
IRestStructureQuery structureQuery;
Assert.Throws<SdmxSemmanticException>(() => structureQuery = new RESTStructureQueryCore(StructureQueryDetail.GetFromEnum(structureQueryDetail), StructureReferenceDetail.GetFromEnum(structureReferenceDetail), SdmxStructureType.GetFromEnum(SdmxStructureEnumType.Code), dataflowRef, returnLatest));
Assert.Throws<SdmxSemmanticException>(() => structureQuery = new RESTStructureQueryCore(StructureQueryDetail.GetFromEnum(structureQueryDetail), StructureReferenceDetail.GetFromEnum(structureReferenceDetail), SdmxStructureType.GetFromEnum(SdmxStructureEnumType.Category), dataflowRef, returnLatest));
Assert.Throws<SdmxSemmanticException>(() => structureQuery = new RESTStructureQueryCore(StructureQueryDetail.GetFromEnum(structureQueryDetail), StructureReferenceDetail.GetFromEnum(structureReferenceDetail), SdmxStructureType.GetFromEnum(SdmxStructureEnumType.Dimension), dataflowRef, returnLatest));
}
public void TestRestStructureQueryExpectedResultTest2(string agency, string id, string version, string expectedResult, StructureQueryDetailEnumType structureQueryDetail, StructureReferenceDetailEnumType structureReferenceDetail)
{
var dataflowRef = new StructureReferenceImpl(SdmxStructureType.GetFromEnum(SdmxStructureEnumType.Dataflow))
{
MaintainableId = id,
AgencyId = agency,
Version = version,
};
string request = GetStructureQueryFormat(dataflowRef, version, structureQueryDetail, structureReferenceDetail);
Assert.IsNotNull(request);
Assert.AreEqual(request, expectedResult);
}