/// <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); }