/// <summary> /// Gets the mutable objects from rest. /// </summary> /// <param name="input"> /// The input. /// </param> /// <param name="dataflowPrincipal"> /// The dataflow principal. /// </param> /// <returns> /// The <see cref="IMutableObjects"/>. /// </returns> private IMutableObjects GetMutableObjectsRest(IRestStructureQuery input, DataflowPrincipal dataflowPrincipal) { IMutableObjects mutableObjects = dataflowPrincipal != null ? this._authStructureSearchManager.GetMaintainables(input, dataflowPrincipal.AllowedDataflows.ToList()) : this._structureSearchManager.GetMaintainables(input); return(mutableObjects); }
public string BuildRestStructureQuery(IRestStructureQuery query) { IStructureQueryFormat<string> structureQueryFormat = new RestQueryFormat(); IStructureQueryFactory structureQueryFactory = new RestStructureQueryFactory(); IStructureQueryBuilderManager structureQueryBuilderManager = new StructureQueryBuilderManager(structureQueryFactory); string restStructureRequest = structureQueryBuilderManager.BuildStructureQuery(query, structureQueryFormat); return restStructureRequest; }
/// <summary> /// Gets the maintainables. /// </summary> /// <param name="structureQuery">The structure query.</param> /// <returns>The <see cref="IMutableObjects"/>.</returns> public IMutableObjects GetMaintainables(IRestStructureQuery structureQuery) { var sdmxObjects = this._sdmxObjectRetrieval.GetMaintainables(structureQuery); if (sdmxObjects != null) { return sdmxObjects.MutableObjects; } return null; }
/// <summary> /// Processes the request. /// </summary> /// <param name="structure">The structure.</param> /// <param name="agencyId">The agency id.</param> /// <param name="resourceId">The resource id.</param> /// <param name="version">The version.</param> /// <param name="ctx">The current <see cref="WebOperationContext"/>.</param> /// <returns> /// The <see cref="Message" />. /// </returns> /// <exception cref="System.Web.HttpBrowserCapabilitiesBase"></exception> /// <exception cref="WebFaultException{String}"> /// Cannot serve content type /// </exception> /// <exception cref="WebFaultException{String}">Cannot serve content type</exception> private Message ProcessRequest(string structure, string agencyId, string resourceId, string version, WebOperationContext ctx) { Match match = Regex.Match(resourceId, @"[A-Za-z0-9\-]+$", RegexOptions.IgnoreCase); if (!match.Success) { throw new WebFaultException(HttpStatusCode.BadRequest); } var defaultMediaType = StructureMediaType.GetFromEnum(StructureMediaEnumType.Structure).MediaTypeName; var requestAccept = ctx.IncomingRequest.Accept; Logger.Info("Got request Content type= " + requestAccept); IList <ContentType> acceptHeaderElements = ctx.IncomingRequest.GetAcceptHeaderElements(); Func <ContentType, bool> predicate = type => StructureMediaType.GetTypeFromName(type.MediaType) != null; var contentType = RestUtils.GetContentType(ctx, predicate, defaultMediaType); string requestedVersion = HeaderUtils.GetVersionFromAccept(acceptHeaderElements, contentType.MediaType); var selectedStructureMediaType = StructureMediaType.GetTypeFromName(contentType.MediaType); var selectedMediaTypeWithVersion = selectedStructureMediaType.GetMediaTypeVersion(requestedVersion); if (selectedMediaTypeWithVersion == null) { Logger.Error("Cannot serve content type: " + requestAccept); throw new WebFaultException <string>("Cannot serve content type: " + requestAccept, HttpStatusCode.NotAcceptable); } Logger.Debug("Select mediatype with version if required: " + selectedMediaTypeWithVersion); SdmxSchema schemaVersion = RestUtils.GetVersionFromMediaType(selectedMediaTypeWithVersion); var context = HttpContext.Current; var controller = this._controllerBuilder.BuildQueryStructureRest(schemaVersion, context.User as DataflowPrincipal); Logger.Info("Selected representation info for the controller: format =" + "TODO" + " , smdx_schema=" + version); IRestStructureQuery query = BuildRestQueryBean(structure, agencyId, resourceId, version, ctx.IncomingRequest.UriTemplateMatch.QueryParameters); var streamController = controller.ParseRequest(query); var charSetEncoding = RestUtils.GetCharSetEncoding(contentType); var responseContentType = RestUtils.GetContentType(contentType, selectedMediaTypeWithVersion); selectedMediaTypeWithVersion.CharSet = charSetEncoding.WebName; return(ctx.CreateStreamResponse( stream => RestUtils.StreamXml(schemaVersion, stream, streamController, charSetEncoding), responseContentType)); }
/// <summary> /// build SdmxParsingObject from IRestStructureQuery /// </summary> /// <param name="query">return object of RESTStructureQueryCore request</param> /// <param name="ConstrainParameter">Parameters for Codelist Contrained</param> /// <returns>SdmxParsingObject</returns> public static SdmxParsingObject Parse(IRestStructureQuery query, string ConstrainParameter) { try { if (query == null) { throw new SdmxException(typeof(SdmxParsingObject), FlyExceptionObject.FlyExceptionTypeEnum.ParsingQueryError); } SdmxParsingObject po = new SdmxParsingObject(query.StructureReference.MaintainableStructureEnumType.EnumType) { MaintainableId = query.StructureReference.MaintainableReference.MaintainableId, AgencyId = query.StructureReference.MaintainableReference.AgencyId, _version = query.StructureReference.MaintainableReference.Version, QueryDetail = query.StructureQueryMetadata.StructureQueryDetail.EnumType, References = query.StructureQueryMetadata.StructureReferenceDetail.EnumType, SpecificReference = query.StructureQueryMetadata.SpecificStructureReference != null ? new List <SdmxStructureType>() { query.StructureQueryMetadata.SpecificStructureReference } : null, }; if (!string.IsNullOrEmpty(ConstrainParameter)) { string dataflowCode = null; string dataflowAgency = null; string dataflowVersion = null; string ConceptCode = null; if (RedirectForCodelistConstrain.ParseContrainReferences(ConstrainParameter, ref dataflowCode, ref dataflowAgency, ref dataflowVersion, ref ConceptCode)) { po.ConstrainDataFlow = dataflowCode; po.ConstrainDataFlowAgency = dataflowAgency; po.ConstrainDataFlowVersion = dataflowVersion; po.ConstrainConcept = ConceptCode; } } return(po); } catch (SdmxException) { throw; } catch (Exception ex) { throw new SdmxException(typeof(SdmxParsingObject), FlyExceptionObject.FlyExceptionTypeEnum.ParsingQueryError, ex); } }
/// <summary> /// Handles the structure request. /// </summary> /// <param name="query">The query.</param> /// <param name="schemaVersion">The schema version.</param> /// <param name="encoding">The encoding.</param> /// <returns>The <see cref="IStreamController{Stream}" />.</returns> public IStreamController<Stream> ParseRequest(IRestStructureQuery query, SdmxSchema schemaVersion, Encoding encoding) { var structureOutputFormat = schemaVersion == SdmxSchemaEnumType.VersionTwoPointOne ? StructureOutputFormat.GetFromEnum(StructureOutputFormatEnumType.SdmxV21StructureDocument) : StructureOutputFormat.GetFromEnum(StructureOutputFormatEnumType.SdmxV2StructureDocument); var sdmxObjects = this._retrieverManager.ParseRequest(schemaVersion, query, this._dataflowPrincipalManager.GetCurrentPrincipal()); return this.GetStreamController(structureOutputFormat, sdmxObjects, encoding); }
/// <summary> /// Gets the structures into an output stream /// </summary> /// <param name="query"> /// The rest structures query /// </param> /// <param name="outputStream"> /// The output stream /// </param> /// <param name="outputFormat"> /// The output fromat /// </param> public void GetStructures(IRestStructureQuery query, Stream outputStream, IStructureFormat outputFormat) { ISdmxObjects beans = _beanRetrievalManager.GetMaintainables(query); _structureWritingManager.WriteStructures(beans, outputFormat, outputStream); }
/// <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> /// Returns a set of maintainable that match the given query parameters /// </summary> /// <param name="structureQuery"> /// The structure Query. /// </param> /// <param name="allowedDataflows"> /// The allowed Dataflows. /// </param> /// <exception cref="ArgumentNullException"> /// <paramref name="structureQuery"/> is null /// </exception> /// <returns> /// The <see cref="IMutableObjects"/>. /// </returns> public virtual IMutableObjects GetMaintainables(IRestStructureQuery structureQuery, IList<IMaintainableRefObject> allowedDataflows) { _log.InfoFormat(CultureInfo.InvariantCulture, "Query for maintainable artefact(s): {0}", structureQuery); if (structureQuery == null) { throw new ArgumentNullException("structureQuery"); } IMutableObjects mutableObjects = new MutableObjectsImpl(); var cachedRetrievalManager = this._advancedMutableRetrievalManagerFactory.GetRetrievalManager(this._retrievalAdvancedManager); var crossReferenceMutableRetrievalManager = this._crossReferenceManager.GetCrossRetrievalManager(this._database, cachedRetrievalManager); this.PopulateMutables( cachedRetrievalManager, mutableObjects, new[] { structureQuery.StructureReference }, structureQuery.StructureQueryMetadata.IsReturnLatest, structureQuery.StructureQueryMetadata.StructureQueryDetail, allowedDataflows, crossReferenceMutableRetrievalManager); GetDetails(structureQuery, mutableObjects, crossReferenceMutableRetrievalManager, allowedDataflows); if (mutableObjects.AllMaintainables.Count == 0) { throw new SdmxNoResultsException("No structures found for the specific query"); } return mutableObjects; }
/// <summary> /// Returns a set of maintainable that match the given query parameters /// </summary> /// <param name="structureQuery"> /// The structure Query. /// </param> /// <param name="allowedDataflows"> /// The allowed Dataflows. /// </param> /// <returns> /// The <see cref="T:Org.Sdmxsource.Sdmx.Api.Model.Mutable.IMutableObjects"/>. /// </returns> public IMutableObjects GetMaintainables(IRestStructureQuery structureQuery, IList<IMaintainableRefObject> allowedDataflows) { return this._authStructureRetriever.GetMaintainables(structureQuery, allowedDataflows); }
/// <summary> /// Returns a set of maintainable that match the given query parameters /// </summary> /// <param name="structureQuery"> /// The structure Query. /// </param> /// <returns> /// The <see cref="T:Org.Sdmxsource.Sdmx.Api.Model.Mutable.IMutableObjects"/>. /// </returns> public IMutableObjects GetMaintainables(IRestStructureQuery structureQuery) { return this._authStructureRetriever.GetMaintainables(structureQuery, null); }
/// <summary> /// Gets the mutable container object. /// </summary> /// <param name="mutableSearchManager"> /// The mutable search manager. /// </param> /// <param name="mockQuery"> /// The mock query. /// </param> /// <param name="maintainableMutableObject"> /// The maintainable mutable object. /// </param> /// <returns> /// The mutable object container. /// </returns> private static IMutableObjects GetMutables(IMutableStructureSearchManager mutableSearchManager, IRestStructureQuery mockQuery, IMaintainableMutableObject maintainableMutableObject) { var mutableObject = mutableSearchManager.GetMaintainables(mockQuery); Assert.IsNotNull(mutableObject, _fromMutable.Build(maintainableMutableObject).ToString()); Assert.IsNotEmpty(mutableObject.AllMaintainables, _fromMutable.Build(maintainableMutableObject).ToString()); return mutableObject; }
/// <summary> /// Parse request from <paramref name="input"/> /// </summary> /// <param name="input"> /// The reader for the SDMX-ML or REST request /// </param> /// <returns> /// The <see cref="IStreamController{TWriter}"/>. /// </returns> public IStreamController <TWriter> ParseRequest(IRestStructureQuery input) { return(this.ParseRequestPrivate(principal => this.GetMutableObjectsRest(input, principal))); }
/// <summary> /// Returns a set of maintainable that match the given query parameters /// </summary> /// <param name="structureQuery"> /// The structure Query. /// </param> /// <param name="allowedDataflows"> /// The allowed Dataflows. /// </param> /// <exception cref="ArgumentNullException"> /// <paramref name="structureQuery"/> is null /// </exception> /// <returns> /// The <see cref="IMutableObjects"/>. /// </returns> public override IMutableObjects GetMaintainables(IRestStructureQuery structureQuery, IList<IMaintainableRefObject> allowedDataflows) { var mutableObjects = base.GetMaintainables(structureQuery, allowedDataflows); mutableObjects.DataStructures.NormalizeSdmxv20DataStructures(); return mutableObjects; }
/// <summary> /// Gets the maintainables. /// </summary> /// <param name="structureQuery">The structure query.</param> /// <param name="allowedDataflows">The allowed dataflows.</param> /// <returns>The <see cref="IMutableObjects" />.</returns> public IMutableObjects GetMaintainables(IRestStructureQuery structureQuery, IList<IMaintainableRefObject> allowedDataflows) { var mutableObjects = this._mutableStructureSearchManager.GetMaintainables(structureQuery); if (allowedDataflows != null) { return new MutableObjectsImpl(mutableObjects.AllMaintainables.Where(o => allowedDataflows.Any(refObject => refObject.IsMatch(o)))); } return mutableObjects; }