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