Exemplo n.º 1
0
        /// <summary>
        /// Returns a list of MaintainableObject that are cross referenced by the given identifiable structure
        /// </summary>
        /// <param name="identifiable">
        /// the identifiable bean to retrieve the references for - What Do I Reference?
        /// </param>
        /// <param name="returnStub">
        /// The return Stub.
        /// </param>
        /// <param name="allowedDataflows">
        /// The allowed Dataflows.
        /// </param>
        /// <param name="structures">
        /// an optional parameter to further filter the list by structure type
        /// </param>
        /// <returns>
        /// The <see cref="IList{IMaintainableMutableObject}"/>.
        /// </returns>
        public IList <IMaintainableMutableObject> GetCrossReferencedStructures(
            IIdentifiableMutableObject identifiable, bool returnStub, IList <IMaintainableRefObject> allowedDataflows, params SdmxStructureType[] structures)
        {
            if (identifiable == null)
            {
                throw new ArgumentNullException("identifiable");
            }

            var sdmxStructureType         = identifiable.StructureType;
            var maintainableMutableObject = identifiable as IMaintainableMutableObject;

            if (!sdmxStructureType.IsMaintainable || maintainableMutableObject == null)
            {
                throw new NotImplementedException(ErrorMessages.CrossReferenceIdentifiable + sdmxStructureType);
            }

            if (maintainableMutableObject.ExternalReference != null && maintainableMutableObject.ExternalReference.IsTrue)
            {
                var structureReference = this._fromMutable.Build(maintainableMutableObject);
                maintainableMutableObject = this.GetMutableMaintainable(structureReference, allowedDataflows);
            }

            Func <IStructureReference, IMaintainableMutableObject> retrievalManager = reference => this.GetMutableMaintainable(reference, allowedDataflows, returnStub);

            var crossReferenceEngine = new CrossReferenceResolverMutableEngine(structures);

            return(new List <IMaintainableMutableObject>(crossReferenceEngine.ResolveReferences(maintainableMutableObject, 1, retrievalManager)));
        }
Exemplo n.º 2
0
        /// <summary>
        /// Builds an <see cref="ISet{IStructureReference}"/> from the specified <paramref name="identifiable"/>
        /// </summary>
        /// <param name="identifiable">
        /// An Object to build the output object from
        /// </param>
        /// <returns>
        /// The <see cref="ISet{IStructureReference}"/> from the specified <paramref name="identifiable"/>
        /// </returns>
        public ISet <IStructureReference> Build(IIdentifiableMutableObject identifiable)
        {
            var structureReferences = new HashSet <IStructureReference>();

            switch (identifiable.StructureType.EnumType)
            {
            case SdmxStructureEnumType.Dataflow:
            {
                // TODO categorisations
                AddReferences(identifiable as IDataflowMutableObject, structureReferences);
            }

            break;

            case SdmxStructureEnumType.Categorisation:
            {
                AddReferences(identifiable as ICategorisationMutableObject, structureReferences);
            }

            break;

            case SdmxStructureEnumType.CategoryScheme:

                // TODO v2.0 DataflowRef
                break;

            case SdmxStructureEnumType.Category:

                // TODO v2.0 DataflowRef
                break;

            case SdmxStructureEnumType.Component:
            case SdmxStructureEnumType.Dimension:
            case SdmxStructureEnumType.PrimaryMeasure:
            case SdmxStructureEnumType.MeasureDimension:
            case SdmxStructureEnumType.TimeDimension:
            case SdmxStructureEnumType.CrossSectionalMeasure:
            case SdmxStructureEnumType.DataAttribute:
            {
                AddReferences(identifiable as IComponentMutableObject, structureReferences);
            }

            break;

            case SdmxStructureEnumType.Dsd:
            {
                AddReferences(identifiable as IDataStructureMutableObject, structureReferences);
            }

            break;

            case SdmxStructureEnumType.HierarchicalCodelist:
            {
                AddReferences(identifiable as IHierarchicalCodelistMutableObject, structureReferences);
            }

            break;
            }

            return(structureReferences);
        }
Exemplo n.º 3
0
        /// <summary>
        /// Returns a list of MaintainableObject that cross reference the given identifiable structure
        /// </summary>
        /// <param name="identifiable">
        /// the identifiable bean to retrieve the references for - Who References Me?
        /// </param>
        /// <param name="returnStub">
        /// The return Stub.
        /// </param>
        /// <param name="allowedDataflows">
        /// The allowed Dataflows.
        /// </param>
        /// <param name="structures">
        /// an optional parameter to further filter the list by structure type
        /// </param>
        /// <returns>
        /// The <see cref="IList{IMaintainableMutableObject}"/>.
        /// </returns>
        public IList <IMaintainableMutableObject> GetCrossReferencingStructures(
            IIdentifiableMutableObject identifiable, bool returnStub, IList <IMaintainableRefObject> allowedDataflows, params SdmxStructureType[] structures)
        {
            var maintainable = identifiable as IMaintainableMutableObject;

            if (maintainable == null)
            {
                throw new NotImplementedException("Only maintainable are supported by this implementation.");
            }

            var structureSet = new HashSet <SdmxStructureType>(structures ?? new SdmxStructureType[0]);
            IStructureReference structureReference = this._fromMutable.Build(maintainable);
            var mutableObjects = new List <IMaintainableMutableObject>();

            switch (identifiable.StructureType.EnumType)
            {
            case SdmxStructureEnumType.Dataflow:
            {
                if (structureSet.HasStructure(SdmxStructureEnumType.Categorisation))
                {
                    ISet <ICategorisationMutableObject> referenced = this._retrievalEngineContainer.CategorisationRetrievalEngine.RetrieveFromReferenced(
                        structureReference, returnStub.GetComplexQueryDetail(), allowedDataflows);
                    mutableObjects.AddRange(referenced);
                }
            }

            break;

            case SdmxStructureEnumType.CodeList:
            {
                if (structureSet.HasStructure(SdmxStructureEnumType.Dsd))
                {
                    ISet <IDataStructureMutableObject> referenced = this._retrievalEngineContainer.DSDRetrievalEngine.RetrieveFromReferenced(
                        structureReference, returnStub.GetComplexQueryDetail());
                    mutableObjects.AddRange(referenced);
                }

                if (structureSet.HasStructure(SdmxStructureEnumType.HierarchicalCodelist))
                {
                    ISet <IHierarchicalCodelistMutableObject> referenced2 = this._retrievalEngineContainer.HclRetrievalEngine.RetrieveFromReferenced(
                        structureReference, returnStub.GetComplexQueryDetail());
                    mutableObjects.AddRange(referenced2);
                }
            }

            break;

            case SdmxStructureEnumType.ConceptScheme:
            {
                if (structureSet.HasStructure(SdmxStructureEnumType.Dsd))
                {
                    ISet <IDataStructureMutableObject> referenced = this._retrievalEngineContainer.DSDRetrievalEngine.RetrieveFromReferenced(
                        structureReference, returnStub.GetComplexQueryDetail());
                    mutableObjects.AddRange(referenced);
                }
            }

            break;

            case SdmxStructureEnumType.CategoryScheme:
            {
                if (structureSet.HasStructure(SdmxStructureEnumType.Categorisation))
                {
                    ISet <ICategorisationMutableObject> referenced = this._retrievalEngineContainer.CategorisationRetrievalEngine.RetrieveFromReferenced(
                        structureReference, returnStub.GetComplexQueryDetail(), allowedDataflows);
                    mutableObjects.AddRange(referenced);
                }
            }

            break;

            case SdmxStructureEnumType.Dsd:
            {
                if (structureSet.HasStructure(SdmxStructureEnumType.Dataflow))
                {
                    ISet <IDataflowMutableObject> referenced = this._retrievalEngineContainer.DataflowRetrievalEngine.RetrieveFromReferenced(
                        structureReference, returnStub.GetComplexQueryDetail(), allowedDataflows);
                    mutableObjects.AddRange(referenced);
                }
            }

            break;
            }

            return(mutableObjects);
        }
Exemplo n.º 4
0
 /// <summary>
 /// Returns a list of MaintainableObject that cross reference the given identifiable structure
 /// </summary>
 /// <param name="identifiable">
 /// the identifiable bean to retrieve the references for - Who References Me?
 /// </param>
 /// <param name="returnStub">
 /// The return Stub.
 /// </param>
 /// <param name="structures">
 /// an optional parameter to further filter the list by structure type
 /// </param>
 /// <returns>
 /// The <see cref="IList{IMaintainableMutableObject}"/>.
 /// </returns>
 public IList <IMaintainableMutableObject> GetCrossReferencingStructures(IIdentifiableMutableObject identifiable, bool returnStub, params SdmxStructureType[] structures)
 {
     return(this.GetCrossReferencingStructures(identifiable, returnStub, null, structures));
 }
 /// <summary>
 /// Write the xml attributes of the given IIdentifiableMutableObject type object
 /// </summary>
 /// <param name="artefact">
 /// The IIdentifiableMutableObject type object to write
 /// </param>
 protected void WriteIdentifiableArtefactAttributes(IIdentifiableMutableObject artefact)
 {
     this.WriteAttributeString(AttributeNameTable.id, artefact.Id);
     this.TryWriteAttribute(AttributeNameTable.uri, artefact.Uri);
     this.TryWriteAttribute(AttributeNameTable.urn, artefact.Urn);
 }
        /// <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;
        }
        ///////////////////////////////////////////////////////////////////////////////////////////////////
        ////////////BUILD FROM MUTABLE OBJECT                 //////////////////////////////////////////////////
        ///////////////////////////////////////////////////////////////////////////////////////////////////    

        /// <summary>
        /// Initializes a new instance of the <see cref="IdentifiableCore"/> class.
        /// </summary>
        /// <param name="itemMutableObject">
        /// The agencySchemeMutable.
        /// </param>
        /// <param name="parent">
        /// The parent.
        /// </param>
        protected internal IdentifiableCore(IIdentifiableMutableObject itemMutableObject, ISdmxStructure parent)
            : base(itemMutableObject, parent)
        {
            this._id = itemMutableObject.Id;
            this.SetUri(itemMutableObject.Uri);
            this.ValidateIdentifiableAttributes();
        }
Exemplo n.º 8
0
 /// <summary>
 /// Gets the reference.
 /// </summary>
 /// <param name="mutableObject">The mutable object.</param>
 /// <param name="identifiableMutableObject">The identifiable mutable object.</param>
 /// <returns>
 /// The <see cref="IStructureReference" />
 /// </returns>
 public static IStructureReference AsReference(this IMaintainableMutableObject mutableObject, IIdentifiableMutableObject identifiableMutableObject)
 {
     return(new StructureReferenceImpl(mutableObject.AgencyId, mutableObject.Id, mutableObject.Version, identifiableMutableObject.StructureType.EnumType, identifiableMutableObject.Id));
 }
Exemplo n.º 9
0
 /// <summary>
 /// Gets the reference.
 /// </summary>
 /// <param name="mutableObject">The mutable object.</param>
 /// <param name="identifiableMutableObject">The identifiable mutable object.</param>
 /// <returns>
 /// The <see cref="IStructureReference" />
 /// </returns>
 public static IStructureReference AsReference(this IMaintainableMutableObject mutableObject, IIdentifiableMutableObject identifiableMutableObject)
 {
     return new StructureReferenceImpl(mutableObject.AgencyId, mutableObject.Id, mutableObject.Version, identifiableMutableObject.StructureType.EnumType, identifiableMutableObject.Id);
 }
        /// <summary>
        /// Returns a list of MaintainableObject that cross reference the given identifiable structure
        /// </summary>
        /// <param name="identifiable">
        /// the identifiable bean to retrieve the references for - Who References Me?
        /// </param>
        /// <param name="returnStub">
        /// The return Stub.
        /// </param>
        /// <param name="allowedDataflows">
        /// The allowed Dataflows.
        /// </param>
        /// <param name="structures">
        /// an optional parameter to further filter the list by structure type
        /// </param>
        /// <returns>
        /// The <see cref="IList{IMaintainableMutableObject}"/>.
        /// </returns>
        public IList<IMaintainableMutableObject> GetCrossReferencingStructures(
            IIdentifiableMutableObject identifiable, bool returnStub, IList<IMaintainableRefObject> allowedDataflows, params SdmxStructureType[] structures)
        {
            var maintainable = identifiable as IMaintainableMutableObject;
            if (maintainable == null)
            {
                throw new NotImplementedException("Only maintainable are supported by this implementation.");
            }

            var structureSet = new HashSet<SdmxStructureType>(structures ?? new SdmxStructureType[0]);
            IStructureReference structureReference = this._fromMutable.Build(maintainable);
            var mutableObjects = new List<IMaintainableMutableObject>();
            switch (identifiable.StructureType.EnumType)
            {
                case SdmxStructureEnumType.Dataflow:
                    {
                        if (structureSet.HasStructure(SdmxStructureEnumType.Categorisation))
                        {
                            ISet<ICategorisationMutableObject> referenced = this._retrievalEngineContainer.CategorisationRetrievalEngine.RetrieveFromReferenced(
                                structureReference, returnStub.GetComplexQueryDetail(), allowedDataflows);
                            mutableObjects.AddRange(referenced);
                        }
                    }

                    break;
                case SdmxStructureEnumType.CodeList:
                    {
                        if (structureSet.HasStructure(SdmxStructureEnumType.Dsd))
                        {
                            ISet<IDataStructureMutableObject> referenced = this._retrievalEngineContainer.DSDRetrievalEngine.RetrieveFromReferenced(
                                structureReference, returnStub.GetComplexQueryDetail());
                            mutableObjects.AddRange(referenced);
                        }

                        if (structureSet.HasStructure(SdmxStructureEnumType.HierarchicalCodelist))
                        {
                            ISet<IHierarchicalCodelistMutableObject> referenced2 = this._retrievalEngineContainer.HclRetrievalEngine.RetrieveFromReferenced(
                                structureReference, returnStub.GetComplexQueryDetail());
                            mutableObjects.AddRange(referenced2);
                        }
                    }

                    break;
                case SdmxStructureEnumType.ConceptScheme:
                    {
                        if (structureSet.HasStructure(SdmxStructureEnumType.Dsd))
                        {
                            ISet<IDataStructureMutableObject> referenced = this._retrievalEngineContainer.DSDRetrievalEngine.RetrieveFromReferenced(
                                structureReference, returnStub.GetComplexQueryDetail());
                            mutableObjects.AddRange(referenced);
                        }
                    }

                    break;
                case SdmxStructureEnumType.CategoryScheme:
                    {
                        if (structureSet.HasStructure(SdmxStructureEnumType.Categorisation))
                        {
                            ISet<ICategorisationMutableObject> referenced = this._retrievalEngineContainer.CategorisationRetrievalEngine.RetrieveFromReferenced(
                                structureReference, returnStub.GetComplexQueryDetail(), allowedDataflows);
                            mutableObjects.AddRange(referenced);
                        }
                    }

                    break;

                case SdmxStructureEnumType.Dsd:
                    {
                        if (structureSet.HasStructure(SdmxStructureEnumType.Dataflow))
                        {
                            ISet<IDataflowMutableObject> referenced = this._retrievalEngineContainer.DataflowRetrievalEngine.RetrieveFromReferenced(
                                structureReference, returnStub.GetComplexQueryDetail(), allowedDataflows);
                            mutableObjects.AddRange(referenced);
                        }
                    }

                    break;
            }

            return mutableObjects;
        }
 /// <summary>
 /// Returns a list of MaintainableObject that cross reference the given identifiable structure
 /// </summary>
 /// <param name="identifiable">
 /// the identifiable bean to retrieve the references for - Who References Me?
 /// </param>
 /// <param name="returnStub">
 /// The return Stub.
 /// </param>
 /// <param name="structures">
 /// an optional parameter to further filter the list by structure type
 /// </param>
 /// <returns>
 /// The <see cref="IList{IMaintainableMutableObject}"/>.
 /// </returns>
 public IList<IMaintainableMutableObject> GetCrossReferencingStructures(IIdentifiableMutableObject identifiable, bool returnStub, params SdmxStructureType[] structures)
 {
     return this.GetCrossReferencingStructures(identifiable, returnStub, null, structures);
 }
        /// <summary>
        /// Returns a list of MaintainableObject that are cross referenced by the given identifiable structure
        /// </summary>
        /// <param name="identifiable">
        /// the identifiable bean to retrieve the references for - What Do I Reference?
        /// </param>
        /// <param name="returnStub">
        /// The return Stub.
        /// </param>
        /// <param name="allowedDataflows">
        /// The allowed Dataflows.
        /// </param>
        /// <param name="structures">
        /// an optional parameter to further filter the list by structure type
        /// </param>
        /// <returns>
        /// The <see cref="IList{IMaintainableMutableObject}"/>.
        /// </returns>
        public IList<IMaintainableMutableObject> GetCrossReferencedStructures(
            IIdentifiableMutableObject identifiable, bool returnStub, IList<IMaintainableRefObject> allowedDataflows, params SdmxStructureType[] structures)
        {
            if (identifiable == null)
            {
                throw new ArgumentNullException("identifiable");
            }

            var sdmxStructureType = identifiable.StructureType;
            var maintainableMutableObject = identifiable as IMaintainableMutableObject;
            if (!sdmxStructureType.IsMaintainable || maintainableMutableObject == null)
            {
                throw new NotImplementedException(ErrorMessages.CrossReferenceIdentifiable + sdmxStructureType);
            }

            if (maintainableMutableObject.ExternalReference != null && maintainableMutableObject.ExternalReference.IsTrue)
            {
                var structureReference = this._fromMutable.Build(maintainableMutableObject);
                maintainableMutableObject = this.GetMutableMaintainable(structureReference, allowedDataflows);
            }

            Func<IStructureReference, IMaintainableMutableObject> retrievalManager = reference => this.GetMutableMaintainable(reference, allowedDataflows, returnStub);

            var crossReferenceEngine = new CrossReferenceResolverMutableEngine(structures);
            return new List<IMaintainableMutableObject>(crossReferenceEngine.ResolveReferences(maintainableMutableObject, 1, retrievalManager));
        }