/// <summary>
/// Initializes a new instance of the <see cref="ResolverBase"/> class.
/// </summary>
/// <param name="crossReferenceManager">
/// The cross reference manager.
/// </param>
/// <exception cref="ArgumentNullException">
/// <paramref name="crossReferenceManager"/> is null.
/// </exception>
protected ResolverBase(IAuthCrossReferenceMutableRetrievalManager crossReferenceManager)
{
if (crossReferenceManager == null)
{
throw new ArgumentNullException("crossReferenceManager");
}
this._crossReferenceManager = crossReferenceManager;
}
/// <summary>
/// Initializes a new instance of the <see cref="CrossReferenceRetrievalManager"/> class.
/// </summary>
/// <param name="retrievalManager">
/// The retrieval manager
/// </param>
/// <param name="connectionStringSettings">
/// The connection String Settings.
/// </param>
public CrossReferenceRetrievalManager(ISdmxMutableObjectRetrievalManager retrievalManager, ConnectionStringSettings connectionStringSettings)
{
if (retrievalManager == null)
{
throw new ArgumentNullException("retrievalManager");
}
this._authCrossReferenceManager = GetAuthCrossReferenceMutableRetrievalManager(retrievalManager, connectionStringSettings);
}
/// <summary>
/// Initializes a new instance of the <see cref="CrossReferenceRetrievalManager"/> class.
/// </summary>
/// <param name="retrievalManager">
/// The retrieval manager
/// </param>
/// <param name="mappingStoreDatabase">
/// The mapping Store Database.
/// </param>
public CrossReferenceRetrievalManager(ISdmxMutableObjectRetrievalManager retrievalManager, Database mappingStoreDatabase)
{
if (retrievalManager == null)
{
throw new ArgumentNullException("retrievalManager");
}
this._authCrossReferenceManager = GetAuthCrossReferenceMutableRetrievalManager(retrievalManager, mappingStoreDatabase);
}
/// <summary>
/// Retrieve the structures referenced by <paramref name="structureQuery" /> and populate the
/// <paramref name="mutableObjects" />
/// </summary>
/// <param name="retrievalManager">The retrieval manager.</param>
/// <param name="mutableObjects">The mutable objects.</param>
/// <param name="structureQuery">The structure query.</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,
IComplexStructureQuery structureQuery,
IList<IMaintainableRefObject> allowedDataflows,
IAuthCrossReferenceMutableRetrievalManager crossReferenceMutableRetrievalManager)
{
//// changes here might also apply to AuthMutableStructureSearchManagerBase and/or AuthStructureRetrieverV21
var complexStructureQueryDetail = structureQuery.StructureQueryMetadata != null ? structureQuery.StructureQueryMetadata.StructureQueryDetail : ComplexStructureQueryDetail.GetFromEnum(ComplexStructureQueryDetailEnumType.Full);
mutableObjects.AddIdentifiables(retrievalManager.GetMutableMaintainables(structureQuery.StructureReference, complexStructureQueryDetail, allowedDataflows));
}
/// <summary>
/// Resolve children of the specified <paramref name="mutableObjects"/> using the specified parameters
/// </summary>
/// <param name="mutableObjects">
/// The mutable objects.
/// </param>
/// <param name="returnStub">
/// Set to true to return only stubs.
/// </param>
/// <param name="crossReferenceMutableRetrievalManager">
/// The cross reference mutable retrieval engine
/// </param>
/// <param name="allowedDataflows">
/// The allowed Dataflows.
/// </param>
private static void ResolveChildren(
IMutableObjects mutableObjects,
bool returnStub,
IAuthCrossReferenceMutableRetrievalManager crossReferenceMutableRetrievalManager,
IList<IMaintainableRefObject> allowedDataflows)
{
Func<IMaintainableMutableObject, IList<IMaintainableMutableObject>> reference =
maintainableMutableObject => crossReferenceMutableRetrievalManager.GetCrossReferencedStructures(maintainableMutableObject, returnStub, allowedDataflows);
Resolve(mutableObjects, reference);
}
/// <summary>
/// Returns an instance of <see cref="ICrossReferenceMutableRetrievalManager"/> created using the specified
/// <paramref name="settings"/>
/// </summary>
/// <typeparam name="T">
/// The type of the settings
/// </typeparam>
/// <param name="settings">
/// The settings.
/// </param>
/// <param name="retrievalManager">
/// The retrieval Manager.
/// </param>
/// <returns>
/// The <see cref="ICrossReferenceMutableRetrievalManager"/>.
/// </returns>
public IAuthCrossReferenceMutableRetrievalManager GetCrossRetrievalManager <T>(T settings, IAuthAdvancedSdmxMutableObjectRetrievalManager retrievalManager)
{
IAuthCrossReferenceMutableRetrievalManager manager = null;
if (this._factoryMethodAdvanced != null)
{
manager = this._factoryMethodAdvanced(settings, retrievalManager);
}
Func <object, IAuthAdvancedSdmxMutableObjectRetrievalManager, IAuthCrossReferenceMutableRetrievalManager> method;
if (_factoryAdvancedMethods.TryGetValue(typeof(T), out method))
{
manager = method(settings, retrievalManager);
}
return(manager);
}
/// <summary>
/// Returns the <see cref="IResolver" /> for the specified <paramref name="referenceDetailType"/>.
/// </summary>
/// <param name="referenceDetailType">Type of the reference detail.</param>
/// <param name="crossReferenceManager">The cross reference manager.</param>
/// <param name="specificStructureTypes">The specific object structure types.</param>
/// <returns>The <see cref="IResolver" /> for the specified <paramref name="referenceDetailType"/>; otherwise null</returns>
public IResolver GetResolver(StructureReferenceDetail referenceDetailType, IAuthCrossReferenceMutableRetrievalManager crossReferenceManager, params SdmxStructureType[] specificStructureTypes)
{
switch (referenceDetailType.EnumType)
{
case StructureReferenceDetailEnumType.Null:
case StructureReferenceDetailEnumType.None:
return new NoneResolver();
case StructureReferenceDetailEnumType.Parents:
return new ParentsResolver(crossReferenceManager);
case StructureReferenceDetailEnumType.ParentsSiblings:
return new ParentsAndSiblingsResolver(crossReferenceManager);
case StructureReferenceDetailEnumType.Children:
return new ChildrenResolver(crossReferenceManager);
case StructureReferenceDetailEnumType.Descendants:
return new DescendantsResolver(crossReferenceManager);
case StructureReferenceDetailEnumType.All:
return new AllResolver(crossReferenceManager);
case StructureReferenceDetailEnumType.Specific:
return new SpecificResolver(crossReferenceManager, specificStructureTypes);
default:
throw new ArgumentOutOfRangeException(referenceDetailType.EnumType.ToString());
}
}
/// <summary>
/// Gets the descendants reference.
/// </summary>
/// <param name="returnStub">
/// if set to <c>true</c> [return stub].
/// </param>
/// <param name="crossReferenceMutableRetrievalManager">
/// The cross reference mutable retrieval manager.
/// </param>
/// <param name="allowedDataflows">
/// The allowed dataflows.
/// </param>
/// <param name="maintainableMutableObject">
/// The maintainable mutable object.
/// </param>
/// <returns>
/// The descendants in <see cref="IList{IMaintainableMutableObject}"/>.
/// </returns>
protected internal static IList<IMaintainableMutableObject> GetDescendantsReference(
bool returnStub,
IAuthCrossReferenceMutableRetrievalManager crossReferenceMutableRetrievalManager,
IList<IMaintainableRefObject> allowedDataflows,
IMaintainableMutableObject maintainableMutableObject)
{
var descendants = new List<IMaintainableMutableObject>();
var stack = new Stack<IMaintainableMutableObject>();
stack.Push(maintainableMutableObject);
while (stack.Count > 0)
{
var descendant = stack.Pop();
descendants.Add(descendant);
var children = crossReferenceMutableRetrievalManager.GetCrossReferencedStructures(descendant, returnStub, allowedDataflows);
for (int i = 0; i < children.Count; i++)
{
stack.Push(children[i]);
}
}
return descendants;
}
/// <summary>
/// Initializes a new instance of the <see cref="ChildrenResolver"/> class.
/// </summary>
/// <param name="crossReferenceManager">
/// The cross reference manager.
/// </param>
/// <exception cref="ArgumentNullException">
/// <paramref name="crossReferenceManager"/> is null.
/// </exception>
public ChildrenResolver(IAuthCrossReferenceMutableRetrievalManager crossReferenceManager)
: base(crossReferenceManager)
{
}
/// <summary>
/// Resolve parents of the specified <paramref name="mutableObjects"/> using the specified
/// </summary>
/// <param name="mutableObjects">
/// The mutable objects.
/// </param>
/// <param name="returnStub">
/// The return Stub.
/// </param>
/// <param name="crossReferenceMutableRetrievalManager">
/// The cross Reference Mutable Retrieval Manager.
/// </param>
/// <param name="allowedDataflow">
/// The allowed Dataflow.
/// </param>
internal static void ResolveParentsAndSiblings(
IMutableObjects mutableObjects,
bool returnStub,
IAuthCrossReferenceMutableRetrievalManager crossReferenceMutableRetrievalManager,
IList<IMaintainableRefObject> allowedDataflow)
{
Func<IMaintainableMutableObject, IList<IMaintainableMutableObject>> reference =
maintainableMutableObject => GetParentsAndSiblingsReference(returnStub, crossReferenceMutableRetrievalManager, allowedDataflow, maintainableMutableObject);
Resolve(mutableObjects, reference);
}
/// <summary>
/// Initializes a new instance of the <see cref="ParentsAndSiblingsResolver"/> class.
/// </summary>
/// <param name="crossReferenceManager">
/// The cross reference manager.
/// </param>
/// <exception cref="ArgumentNullException">
/// <paramref name="crossReferenceManager"/> is null.
/// </exception>
public ParentsAndSiblingsResolver(IAuthCrossReferenceMutableRetrievalManager crossReferenceManager)
: base(crossReferenceManager)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="CrossReferenceRetrievalManager"/> class.
/// </summary>
/// <param name="authCrossReferenceManager">The authentication cross reference manager.</param>
public CrossReferenceRetrievalManager(IAuthCrossReferenceMutableRetrievalManager authCrossReferenceManager)
{
this._authCrossReferenceManager = authCrossReferenceManager;
}
/// <summary>
/// Resolve parents of the specified <paramref name="mutableObjects"/> using the specified
/// </summary>
/// <param name="mutableObjects">
/// The mutable objects.
/// </param>
/// <param name="returnStub">
/// The return Stub.
/// </param>
/// <param name="crossReferenceMutableRetrievalManager">
/// The cross Reference Mutable Retrieval Manager.
/// </param>
/// <param name="allowedDataflow">
/// The allowed Dataflow.
/// </param>
internal static void ResolveParents(
IMutableObjects mutableObjects,
bool returnStub,
IAuthCrossReferenceMutableRetrievalManager crossReferenceMutableRetrievalManager,
IList<IMaintainableRefObject> allowedDataflow)
{
Func<IMaintainableMutableObject, IList<IMaintainableMutableObject>> reference =
maintainableMutableObject => crossReferenceMutableRetrievalManager.GetCrossReferencingStructures(maintainableMutableObject, returnStub, allowedDataflow);
Resolve(mutableObjects, reference);
}
/// <summary>
/// Resolve children of the specified <paramref name="mutableObjects"/> using the specified parameters
/// </summary>
/// <param name="mutableObjects">
/// The mutable objects.
/// </param>
/// <param name="returnStub">
/// Set to true to return only stubs.
/// </param>
/// <param name="crossReferenceMutableRetrievalManager">
/// The cross reference mutable retrieval engine
/// </param>
/// <param name="allowedDataflows">
/// The allowed Dataflows.
/// </param>
internal static void ResolveAll(
IMutableObjects mutableObjects,
bool returnStub,
IAuthCrossReferenceMutableRetrievalManager crossReferenceMutableRetrievalManager,
IList<IMaintainableRefObject> allowedDataflows)
{
Func<IMaintainableMutableObject, IList<IMaintainableMutableObject>> reference = maintainableMutableObject =>
{
var all = new List<IMaintainableMutableObject>();
// add descendants
all.AddRange(GetDescendantsReference(returnStub, crossReferenceMutableRetrievalManager, allowedDataflows, maintainableMutableObject));
// add parents and siblings
all.AddRange(GetParentsAndSiblingsReference(returnStub, crossReferenceMutableRetrievalManager, allowedDataflows, maintainableMutableObject));
return all;
};
Resolve(mutableObjects, reference);
}
/// <summary>
/// Initializes a new instance of the <see cref="DescendantsResolver"/> class.
/// </summary>
/// <param name="crossReferenceManager">
/// The cross reference manager.
/// </param>
/// <exception cref="ArgumentNullException">
/// <paramref name="crossReferenceManager"/> is null.
/// </exception>
public DescendantsResolver(IAuthCrossReferenceMutableRetrievalManager crossReferenceManager)
: base(crossReferenceManager)
{
}
/// <summary>
/// Resolve the specified <paramref name="specificStructureReferences"/> only reference from
/// <paramref name="mutableObjects"/>
/// </summary>
/// <param name="mutableObjects">
/// The mutable objects.
/// </param>
/// <param name="specificStructureReferences">
/// The specific structure reference.
/// </param>
/// <param name="returnStub">
/// The return Stub.
/// </param>
/// <param name="crossReferenceMutableRetrievalManager">
/// The cross Reference Mutable Retrieval Manager.
/// </param>
/// <param name="allowedDataflow">
/// The allowed Dataflow.
/// </param>
internal static void ResolveSpecific(
IMutableObjects mutableObjects,
IList<SdmxStructureType> specificStructureReferences,
bool returnStub,
IAuthCrossReferenceMutableRetrievalManager crossReferenceMutableRetrievalManager,
IList<IMaintainableRefObject> allowedDataflow)
{
Func<IMaintainableMutableObject, IList<IMaintainableMutableObject>> reference = maintainableMutableObject =>
{
var referencedStructures = new List<IMaintainableMutableObject>();
foreach (var specificStructureType in specificStructureReferences)
{
referencedStructures.AddRange(GetSpecificObjects(crossReferenceMutableRetrievalManager, maintainableMutableObject, specificStructureType, returnStub, allowedDataflow));
}
return referencedStructures;
};
Resolve(mutableObjects, reference);
}
/// <summary>
/// Get details specified in <paramref name="structureQuery"/> of the specified <paramref name="mutableObjects"/>
/// </summary>
/// <param name="structureQuery">
/// The structure query.
/// </param>
/// <param name="mutableObjects">
/// The mutable objects.
/// </param>
/// <param name="crossReferenceMutableRetrievalManager">
/// The cross Reference Mutable Retrieval Manager.
/// </param>
/// <param name="allowedDataflow">
/// The allowed Dataflow.
/// </param>
/// <exception cref="NotImplementedException">
/// Not implemented value at <see cref="StructureReferenceDetail"/> of <paramref name="structureQuery"/>
/// </exception>
/// <exception cref="ArgumentOutOfRangeException">
/// Invalid value at <see cref="StructureReferenceDetail"/> of <paramref name="structureQuery"/>
/// </exception>
private static void GetDetails(
IRestStructureQuery structureQuery,
IMutableObjects mutableObjects,
IAuthCrossReferenceMutableRetrievalManager crossReferenceMutableRetrievalManager,
IList<IMaintainableRefObject> allowedDataflow)
{
_log.InfoFormat("Reference detail: {0}", structureQuery.StructureQueryMetadata.StructureReferenceDetail);
bool returnStub = structureQuery.StructureQueryMetadata.StructureQueryDetail.EnumType != StructureQueryDetailEnumType.Full;
var resolver = _resolverFactory.GetResolver(
structureQuery.StructureQueryMetadata.StructureReferenceDetail,
crossReferenceMutableRetrievalManager,
structureQuery.StructureQueryMetadata.SpecificStructureReference);
resolver.ResolveReferences(mutableObjects, returnStub, allowedDataflow);
}
/// <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>
/// Initializes a new instance of the <see cref="SpecificResolver"/> class.
/// </summary>
/// <param name="crossReferenceManager">
/// The cross reference manager.
/// </param>
/// <param name="structureTypes">
/// The specific object structure Types.
/// </param>
/// <exception cref="ArgumentNullException">
/// <paramref name="crossReferenceManager"/> is null.
/// </exception>
public SpecificResolver(IAuthCrossReferenceMutableRetrievalManager crossReferenceManager, params SdmxStructureType[] structureTypes)
: base(crossReferenceManager)
{
this._structureTypes = structureTypes;
}
/// <summary>
/// Processes the node.
/// </summary>
/// <param name="crossReferenceManager">The cross reference manager.</param>
/// <param name="maintainable">The maintainable.</param>
/// <param name="specificStructureType">Type of the specific structure.</param>
/// <param name="returnStub">if set to <c>true</c> [return stub].</param>
/// <param name="allowedDataflows">The allowed dataflows.</param>
/// <param name="rootNode">The root node.</param>
/// <param name="specificObjects">The specific objects.</param>
/// <param name="stack">The stack.</param>
private static void ProcessNode(
IAuthCrossReferenceMutableRetrievalManager crossReferenceManager,
IMaintainableMutableObject maintainable,
BaseConstantType<SdmxStructureEnumType> specificStructureType,
bool returnStub,
IList<IMaintainableRefObject> allowedDataflows,
RelationNode rootNode,
ICollection<IMaintainableMutableObject> specificObjects,
Stack<IMaintainableMutableObject> stack)
{
var isTarget = rootNode.DestType == specificStructureType.EnumType;
bool getStub;
Action<IMaintainableMutableObject> action;
if (isTarget)
{
getStub = returnStub;
action = specificObjects.Add;
}
else
{
getStub = rootNode.DestType != SdmxStructureEnumType.Categorisation;
action = stack.Push;
}
var rootFunc = GetFunc(crossReferenceManager, getStub, allowedDataflows, rootNode);
foreach (var maintainableMutableObject in rootFunc(maintainable))
{
action(maintainableMutableObject);
}
}
/// <summary>
/// Returns specific structures of the specified type <paramref name="specificStructureType"/> related to the <paramref name="maintainable"/>
/// </summary>
/// <param name="crossReferenceManager">
/// The cross reference manager.
/// </param>
/// <param name="maintainable">
/// The maintainable.
/// </param>
/// <param name="specificStructureType">
/// The specific structure type.
/// </param>
/// <param name="returnStub">
/// The return stub.
/// </param>
/// <param name="allowedDataflows">
/// The allowed dataflows.
/// </param>
/// <returns>
/// The <see cref="IEnumerable{IMaintainableMutableObject}"/>.
/// </returns>
private static IEnumerable<IMaintainableMutableObject> GetSpecificObjects(
IAuthCrossReferenceMutableRetrievalManager crossReferenceManager,
IMaintainableMutableObject maintainable,
BaseConstantType<SdmxStructureEnumType> specificStructureType,
bool returnStub,
IList<IMaintainableRefObject> allowedDataflows)
{
var specificObjects = new List<IMaintainableMutableObject>();
var relationNodes = RelationBuilder.Build(maintainable.StructureType.EnumType, specificStructureType.EnumType);
var stack = new Stack<IMaintainableMutableObject>();
foreach (var rootNode in relationNodes)
{
ProcessNode(crossReferenceManager, maintainable, specificStructureType, returnStub, allowedDataflows, rootNode, specificObjects, stack);
while (stack.Count > 0)
{
var current = stack.Pop();
var currentNode = RelationBuilder.Build(current.StructureType.EnumType, specificStructureType.EnumType).FirstOrDefault();
if (currentNode != null)
{
ProcessNode(crossReferenceManager, current, specificStructureType, returnStub, allowedDataflows, currentNode, specificObjects, stack);
}
}
}
return specificObjects;
}
/// <summary>
/// Returns the method that retrieves the
/// </summary>
/// <param name="crossReferenceManager">
/// The cross reference manager.
/// </param>
/// <param name="returnStub">
/// The return stub.
/// </param>
/// <param name="allowedDataflows">
/// The allowed dataflows.
/// </param>
/// <param name="relationNode">
/// The relation node.
/// </param>
/// <returns>
/// The function that returns
/// </returns>
private static Func<IMaintainableMutableObject, IList<IMaintainableMutableObject>> GetFunc(
IAuthCrossReferenceMutableRetrievalManager crossReferenceManager,
bool returnStub,
IList<IMaintainableRefObject> allowedDataflows,
RelationNode relationNode)
{
Func<IMaintainableMutableObject, IList<IMaintainableMutableObject>> func = x => new IMaintainableMutableObject[0];
var destinationType = SdmxStructureType.GetFromEnum(relationNode.DestType);
switch (relationNode.RelationType)
{
case RelationType.Parent:
func = x => crossReferenceManager.GetCrossReferencingStructures(x, returnStub, allowedDataflows, destinationType);
break;
case RelationType.Descendant:
func = x => crossReferenceManager.GetCrossReferencedStructures(x, returnStub, allowedDataflows, destinationType);
break;
}
return func;
}
/// <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>
/// Gets the parents and siblings reference.
/// </summary>
/// <param name="returnStub">
/// if set to <c>true</c> [return stub].
/// </param>
/// <param name="crossReferenceMutableRetrievalManager">
/// The cross reference mutable retrieval manager.
/// </param>
/// <param name="allowedDataflow">
/// The allowed dataflow.
/// </param>
/// <param name="maintainableMutableObject">
/// The maintainable mutable object.
/// </param>
/// <returns>
/// The parents and siblings in a <see cref="IList{IMaintainableMutableObject}"/>.
/// </returns>
protected internal static IList<IMaintainableMutableObject> GetParentsAndSiblingsReference(
bool returnStub,
IAuthCrossReferenceMutableRetrievalManager crossReferenceMutableRetrievalManager,
IList<IMaintainableRefObject> allowedDataflow,
IIdentifiableMutableObject maintainableMutableObject)
{
// get parents
var parents = crossReferenceMutableRetrievalManager.GetCrossReferencingStructures(maintainableMutableObject, returnStub, allowedDataflow);
var parentsAndSiblings = new List<IMaintainableMutableObject>(parents);
foreach (var parent in parents)
{
// get siblinks
var siblings = crossReferenceMutableRetrievalManager.GetCrossReferencedStructures(parent, returnStub, allowedDataflow);
parentsAndSiblings.AddRange(siblings);
}
return parentsAndSiblings;
}
/// <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>
/// Get details specified in <paramref name="structureQuery"/> of the specified <paramref name="mutableObjects"/>
/// </summary>
/// <param name="structureQuery">
/// The structure query.
/// </param>
/// <param name="mutableObjects">
/// The mutable objects.
/// </param>
/// <param name="crossReferenceMutableRetrievalManager">
/// The cross Reference Mutable Retrieval Manager.
/// </param>
/// <param name="allowedDataflow">
/// The allowed Dataflow.
/// </param>
/// <exception cref="NotImplementedException">
/// Not implemented value at <see cref="StructureReferenceDetail"/> of <paramref name="structureQuery"/>
/// </exception>
/// <exception cref="ArgumentOutOfRangeException">
/// Invalid value at <see cref="StructureReferenceDetail"/> of <paramref name="structureQuery"/>
/// </exception>
private static void GetDetails(
IComplexStructureQuery structureQuery,
IMutableObjects mutableObjects,
IAuthCrossReferenceMutableRetrievalManager crossReferenceMutableRetrievalManager,
IList<IMaintainableRefObject> allowedDataflow)
{
_log.InfoFormat("Reference detail: {0}", structureQuery.StructureQueryMetadata.StructureReferenceDetail);
bool returnStub = structureQuery.StructureQueryMetadata.StructureQueryDetail.EnumType != ComplexStructureQueryDetailEnumType.Full;
StructureReferenceDetail referenceDetail = structureQuery.StructureQueryMetadata.StructureReferenceDetail ?? StructureReferenceDetail.GetFromEnum(StructureReferenceDetailEnumType.None);
var specificStructureTypes = structureQuery.StructureQueryMetadata.ReferenceSpecificStructures != null ? structureQuery.StructureQueryMetadata.ReferenceSpecificStructures.ToArray() : null;
var resolver = _resolverFactory.GetResolver(referenceDetail, crossReferenceMutableRetrievalManager, specificStructureTypes);
resolver.ResolveReferences(mutableObjects, returnStub, allowedDataflow);
}
