public object Get(ActivitySearchRequestTep request)
{
var context = TepWebContext.GetWebContext(PagePrivileges.UserView);
context.AccessLevel = EntityAccessLevel.Administrator;
context.Open();
context.LogInfo(this, string.Format("/activity/search GET nologin='******'", request.nologin));
EntityList <ActivityTep> activities = new EntityList <ActivityTep>(context);
activities.AddSort("CreationTime", SortDirection.Descending);
// Load the complete request
HttpRequest httpRequest = HttpContext.Current.Request;
OpenSearchEngine ose = MasterCatalogue.OpenSearchEngine;
Type responseType = OpenSearchFactory.ResolveTypeFromRequest(httpRequest.QueryString, httpRequest.Headers, ose);
IOpenSearchResultCollection osr = ose.Query(activities, httpRequest.QueryString, responseType);
activities.Identifier = "activity";
OpenSearchFactory.ReplaceOpenSearchDescriptionLinks(activities, osr);
context.Close();
return(new HttpResult(osr.SerializeToString(), osr.ContentType));
}
public PartialAtomException(string message = null, IOpenSearchResultCollection openSearchResultCollection = null) : base(message)
{
if (openSearchResultCollection != null)
{
PartialOpenSearchResultCollection = openSearchResultCollection;
}
}
public object Get(ServiceServiceTep request)
{
var context = TepWebContext.GetWebContext(PagePrivileges.UserView);
context.Open();
EntityList <Terradue.Portal.Service> services = new EntityList <Terradue.Portal.Service>(context);
services.Load();
// Load the complete request
HttpRequest httpRequest = HttpContext.Current.Request;
OpenSearchEngine ose = MasterCatalogue.OpenSearchEngine;
string format;
if (Request.QueryString["format"] == null)
{
format = "atom";
}
else
{
format = Request.QueryString["format"];
}
Type responseType = OpenSearchFactory.ResolveTypeFromRequest(httpRequest.QueryString, httpRequest.Headers, ose);
IOpenSearchResultCollection osr = ose.Query(services, httpRequest.QueryString, responseType);
context.Close();
return(new HttpResult(osr.SerializeToString(), osr.ContentType));
}
public object Get(SearchRssNews request)
{
var context = TepWebContext.GetWebContext(PagePrivileges.EverybodyView);
IOpenSearchResultCollection result = null;
try{
context.Open();
context.LogInfo(this, string.Format("/news/rss/search GET"));
// Load the complete request
HttpRequest httpRequest = HttpContext.Current.Request;
OpenSearchEngine ose = MasterCatalogue.OpenSearchEngine;
Type type = OpenSearchFactory.ResolveTypeFromRequest(httpRequest.QueryString, httpRequest.Headers, ose);
EntityList <RssNews> rss = new EntityList <RssNews>(context);
rss.Load();
var settings = MasterCatalogue.OpenSearchFactorySettings;
MultiGenericOpenSearchable multiOSE = new MultiGenericOpenSearchable(rss.Cast <IOpenSearchable>().ToList(), settings);
result = ose.Query(multiOSE, httpRequest.QueryString, type);
context.Close();
}catch (Exception e) {
context.LogError(this, e.Message, e);
context.Close();
throw e;
}
return(new HttpResult(result.SerializeToString(), result.ContentType));
}
/// <summary>
/// Get the specified request.
/// </summary>
/// <param name="request">Request.</param>
public object Get(DataPackageSearchDefaultRequestTep request)
{
var context = TepWebContext.GetWebContext(PagePrivileges.EverybodyView);
IOpenSearchResultCollection result = null;
try {
context.Open();
context.LogInfo(this, string.Format("/data/package/default/search GET"));
Terradue.Tep.DataPackage datapackage = DataPackage.GetTemporaryForCurrentUser(context);
datapackage.SetOpenSearchEngine(MasterCatalogue.OpenSearchEngine);
OpenSearchEngine ose = MasterCatalogue.OpenSearchEngine;
Type responseType = OpenSearchFactory.ResolveTypeFromRequest(HttpContext.Current.Request.QueryString, HttpContext.Current.Request.Headers, ose);
List <Terradue.OpenSearch.IOpenSearchable> osentities = new List <Terradue.OpenSearch.IOpenSearchable>();
osentities.AddRange(datapackage.GetOpenSearchableArray());
var settings = MasterCatalogue.OpenSearchFactorySettings;
MultiGenericOpenSearchable multiOSE = new MultiGenericOpenSearchable(osentities, settings);
result = ose.Query(multiOSE, Request.QueryString, responseType);
MasterCatalogue.ReplaceSelfLinksFormat(result, Request.QueryString);
context.Close();
} catch (Exception e) {
context.LogError(this, e.Message, e);
context.Close();
throw e;
}
return(new HttpResult(result.SerializeToString(), result.ContentType));
}
public void SearchRssFeeds()
{
var ose = MasterCatalogue.OpenSearchEngine;
var settings = new OpenSearchableFactorySettings(ose);
List <Terradue.OpenSearch.IOpenSearchable> osentities = new List <Terradue.OpenSearch.IOpenSearchable>();
var parameters = new NameValueCollection();
parameters.Set("count", "20");
try {
EntityList <RssNews> rsss = new EntityList <RssNews>(context);
rsss.Load();
if (rsss != null)
{
foreach (RssNews rss in rsss)
{
osentities.Add(rss);
}
}
MultiGenericOpenSearchable multiOSE = new MultiGenericOpenSearchable(osentities, settings);
IOpenSearchResultCollection osr = ose.Query(multiOSE, parameters);
Assert.That(osr.TotalResults > 0);
} catch (Exception e) {
Assert.Fail(e.Message);
} finally {
context.EndImpersonation();
}
}
public object Get(UserSearchRequest request)
{
var context = TepWebContext.GetWebContext(PagePrivileges.UserView);
context.Open();
context.LogInfo(this, string.Format("/user/search GET"));
EntityList <UserTep> users = new EntityList <UserTep> (context);
users.AddSort("Identifier", SortDirection.Ascending);
// Load the complete request
HttpRequest httpRequest = HttpContext.Current.Request;
OpenSearchEngine ose = MasterCatalogue.OpenSearchEngine;
string format;
if (Request.QueryString ["format"] == null)
{
format = "atom";
}
else
{
format = Request.QueryString ["format"];
}
Type responseType = OpenSearchFactory.ResolveTypeFromRequest(httpRequest.QueryString, httpRequest.Headers, ose);
IOpenSearchResultCollection osr = ose.Query(users, httpRequest.QueryString, responseType);
OpenSearchFactory.ReplaceOpenSearchDescriptionLinks(users, osr);
context.Close();
return(new HttpResult(osr.SerializeToString(), osr.ContentType));
}
public PartialAtomSearchResponse(AtomFeed result, TimeSpan timeSpan, IOpenSearchResultCollection partialOpenSearchResultCollection = null) : base(result, timeSpan)
{
if (partialOpenSearchResultCollection != null)
{
PartialOpenSearchResultCollection = partialOpenSearchResultCollection;
}
}
public BulkOperationsResponse Delete(IOpenSearchableElasticType type, IOpenSearchResultCollection results)
{
BulkRequest bulkRequest = new BulkRequest() {
Refresh = true,
Consistency = Consistency.One,
Index = type.Index,
Type = type.Type,
Operations = new List<IBulkOperation>()
};
foreach (var doc in results.Items) {
var bulkDeleteOperation = new BulkDeleteOperation<IElasticItem>(doc.Identifier);
bulkDeleteOperation.Type = type.Type.Name;
var bulkOp = bulkDeleteOperation;
bulkRequest.Operations.Add(bulkOp);
}
var response = client.Bulk(bulkRequest);
BulkOperationsResponse ingestionResponse = new BulkOperationsResponse();
foreach (var item in response.Items) {
if (!item.IsValid) {
ingestionResponse.Errors++;
} else {
ingestionResponse.Deleted++;
}
}
return ingestionResponse;
}
public object Get(CommunitySearchRequestTep request)
{
var context = TepWebContext.GetWebContext(PagePrivileges.EverybodyView);
context.Open();
context.LogInfo(this, string.Format("/community/search GET"));
CommunityCollection domains = new CommunityCollection(context);
domains.UserStatus = Request.QueryString != null ? Request.QueryString["status"] : null;
domains.SetFilter("Kind", (int)DomainKind.Public + "," + (int)DomainKind.Private + "," + (int)DomainKind.Hidden);
// Load the complete request
HttpRequest httpRequest = HttpContext.Current.Request;
OpenSearchEngine ose = MasterCatalogue.OpenSearchEngine;
Type responseType = OpenSearchFactory.ResolveTypeFromRequest(httpRequest.QueryString, httpRequest.Headers, ose);
// the opensearch cache system uses the query parameters
// we add to the parameters the filters added to the load in order to avoir wrong cache
// we use 't2-' in order to not interfer with possibly used query parameters
var qs = new NameValueCollection(Request.QueryString);
foreach (var filter in domains.FilterValues)
{
qs.Add("t2-" + filter.Key.FieldName, filter.Value.ToString());
}
IOpenSearchResultCollection osr = ose.Query(domains, httpRequest.QueryString, responseType);
OpenSearchFactory.ReplaceOpenSearchDescriptionLinks(domains, osr);
context.Close();
return(new HttpResult(osr.SerializeToString(), osr.ContentType));
}
/// <summary>
/// Get the specified request.
/// </summary>
/// <param name="request">Request.</param>
public object Get(GetOpensearchSearchs request)
{
// This page is public
// But its content will be adapted accrding to context (user id, ...)
// Load the complete request
HttpRequest httpRequest = HttpContext.Current.Request;
var context = TepWebContext.GetWebContext(PagePrivileges.EverybodyView);
IOpenSearchResultCollection result = null;
try{
context.Open();
context.LogInfo(this, string.Format("/data/collection/search GET"));
EntityList <Collection> collections = new EntityList <Collection>(context);
collections.AddSort("Name", SortDirection.Ascending);
OpenSearchEngine ose = MasterCatalogue.OpenSearchEngine;
Type responseType = OpenSearchFactory.ResolveTypeFromRequest(httpRequest.QueryString, httpRequest.Headers, ose);
result = ose.Query(collections, httpRequest.QueryString, responseType);
context.Close();
}catch (Exception e) {
context.LogError(this, e.Message, e);
context.Close();
throw e;
}
return(new HttpResult(result.SerializeToString(), result.ContentType));
}
public object Get(DomainSearchRequestTep request)
{
var context = TepWebContext.GetWebContext(PagePrivileges.EverybodyView);
context.Open();
context.LogInfo(this, string.Format("/domain/search GET"));
EntityList <Domain> domains = new EntityList <Domain> (context);
domains.Load();
// Load the complete request
HttpRequest httpRequest = HttpContext.Current.Request;
OpenSearchEngine ose = MasterCatalogue.OpenSearchEngine;
string format;
if (Request.QueryString ["format"] == null)
{
format = "atom";
}
else
{
format = Request.QueryString ["format"];
}
Type responseType = OpenSearchFactory.ResolveTypeFromRequest(httpRequest.QueryString, httpRequest.Headers, ose);
IOpenSearchResultCollection osr = ose.Query(domains, httpRequest.QueryString, responseType);
OpenSearchFactory.ReplaceOpenSearchDescriptionLinks(domains, osr);
context.Close();
return(new HttpResult(osr.SerializeToString(), osr.ContentType));
}
public static void ReplaceSelfLinksFormat(IOpenSearchResultCollection result, NameValueCollection queryString)
{
foreach (IOpenSearchResultItem item in result.Items)
{
var matchLinks = item.Links.Where(l => l.RelationshipType == "self").ToArray();
string self = "";
foreach (var link in matchLinks)
{
self = link.Uri.AbsoluteUri;
item.Links.Remove(link);
}
if (self != null)
{
UriBuilder urib = new UriBuilder(self);
var nvc = HttpUtility.ParseQueryString(urib.Query);
if (queryString["format"] != null)
{
nvc.Set("format", queryString["format"]);
}
urib.Query = string.Join("&", nvc.AllKeys.Where(key => !string.IsNullOrWhiteSpace(nvc[key])).Select(key => string.Format("{0}={1}", HttpUtility.UrlEncode(key), HttpUtility.UrlEncode(nvc[key]))));
item.Links.Add(new SyndicationLink(urib.Uri, "self", "Reference link", result.ContentType, 0));
}
}
}
public new void ApplyResultFilters(OpenSearchRequest request, ref IOpenSearchResultCollection osr, string finalContentType)
{
log.DebugFormat("Applying Fedeo source harvesting");
base.ApplyResultFilters(request, ref osr, finalContentType);
QueryEarthObservationResult(ref osr);
}
public new void ApplyResultFilters(OpenSearchRequest request, ref IOpenSearchResultCollection osr, string finalContentType)
{
log.DebugFormat("Applying Fedeo source harvesting");
base.ApplyResultFilters(request, ref osr, finalContentType);
QueryEarthObservationResult(ref osr);
}
public object Get(SearchNews request)
{
var context = TepWebContext.GetWebContext(PagePrivileges.EverybodyView);
IOpenSearchResultCollection result = null;
try{
context.Open();
context.LogInfo(this, string.Format("/news/search GET"));
// Load the complete request
HttpRequest httpRequest = HttpContext.Current.Request;
OpenSearchEngine ose = MasterCatalogue.OpenSearchEngine;
Type type = OpenSearchFactory.ResolveTypeFromRequest(httpRequest.QueryString, httpRequest.Headers, ose);
List <Terradue.OpenSearch.IOpenSearchable> osentities = new List <Terradue.OpenSearch.IOpenSearchable>();
//try{
// EntityList<Article> articles = new EntityList<Article>(context);
// articles.Load();
// osentities.Add(articles);
//}catch(Exception){}
try{
var twitters = TwitterNews.LoadTwitterCollection(context);
osentities.Add(twitters);
}catch (Exception) {}
try{
EntityList <RssNews> rsss = new EntityList <RssNews>(context);
rsss.Load();
if (rsss != null)
{
foreach (RssNews rss in rsss)
{
osentities.Add(rss);
}
}
}catch (Exception) {}
var settings = MasterCatalogue.OpenSearchFactorySettings;
MultiGenericOpenSearchable multiOSE = new MultiGenericOpenSearchable(osentities, settings);
result = ose.Query(multiOSE, httpRequest.QueryString, type);
context.Close();
}catch (Exception e) {
context.LogError(this, e.Message, e);
context.Close();
throw e;
}
return(new HttpResult(result.SerializeToString(), result.ContentType));
}
public void SearchWpsServicesByQ()
{
var uid = Guid.NewGuid().ToString();
WpsProvider provider = CreateProvider(uid, "test provider", "http://gpod.eo.esa.int/wps?service=WPS&version=1.0.0&request=GetCapabilities", true);
provider.UpdateProcessOfferings(true);
EntityList <WpsProcessOffering> wpsProcessList = new EntityList <WpsProcessOffering>(context);
wpsProcessList.Template.Provider = provider;
wpsProcessList.Load();
var nbprocesses = wpsProcessList.Items.Count();
WpsProcessOffering service1 = wpsProcessList.Items.First();
service1.Identifier = "searchbyQidentifier";
service1.Name = "searchbyQname";
service1.Description = "searchbyQdescription";
service1.Store();
EntityList <WpsProcessOffering> services = new EntityList <WpsProcessOffering>(context);
var parameters = new NameValueCollection();
parameters.Set("count", (nbprocesses + 1) + "");
IOpenSearchResultCollection osr = ose.Query(services, parameters);
parameters.Set("q", "searchbyNoQidentifier");
osr = ose.Query(services, parameters);
Assert.AreEqual(0, osr.Items.Count());
services = new EntityList <WpsProcessOffering>(context);
parameters.Set("q", "searchbyQ");
osr = ose.Query(services, parameters);
Assert.AreEqual(1, osr.Items.Count());
services = new EntityList <WpsProcessOffering>(context);
parameters.Set("q", "searchbyQidentifier");
osr = ose.Query(services, parameters);
Assert.AreEqual(1, osr.Items.Count());
services = new EntityList <WpsProcessOffering>(context);
parameters.Set("q", "searchbyQname");
osr = ose.Query(services, parameters);
Assert.AreEqual(1, osr.Items.Count());
services = new EntityList <WpsProcessOffering>(context);
parameters.Set("q", "searchbyQdescription");
osr = ose.Query(services, parameters);
Assert.AreEqual(1, osr.Items.Count());
provider.Delete();
}
/// <summary>
/// Applies the result filters.
/// </summary>
/// <param name="request">Request.</param>
/// <param name="osr">Osr.</param>
/// <param name="finalContentType">Final content type.</param>
public void ApplyResultFilters(OpenSearchRequest request, ref IOpenSearchResultCollection osr, string finalContentType = null)
{
if (finalContentType != null)
{
ReplaceEnclosureLinks(this, request.OriginalParameters, osr, finalContentType);
}
else
{
ReplaceEnclosureLinks(this, request.OriginalParameters, osr, osr.ContentType);
}
}
public IOpenSearchResultCollection Sentinel1QcReadNative(IOpenSearchResponse response)
{
IOpenSearchResultCollection openSearchResultCollection = originalReadNativeFunctionToExtend(response);
if (response.GetType() == typeof(PartialAtomSearchResponse))
{
throw new PartialAtomException("Attaching result to exception ", null, openSearchResultCollection);
}
return(openSearchResultCollection);
}
public PartialAtomException(string message = null, List <AtomItem> items = null, IOpenSearchResultCollection openSearchResultCollection = null) : base(message)
{
if (items != null)
{
Items = items;
}
if (openSearchResultCollection != null)
{
PartialOpenSearchResultCollection = openSearchResultCollection;
}
}
/// <summary>
/// Get the specified request.
/// </summary>
/// <param name="request">Request.</param>
public object Get(DataPackagesSearchRequest request)
{
var context = TepWebContext.GetWebContext(PagePrivileges.EverybodyView);
IOpenSearchResultCollection result = null;
try {
context.Open();
context.LogInfo(this, string.Format("/data/package/search GET"));
EntityList <Terradue.Tep.DataPackage> datapackages = new EntityList <DataPackage>(context);
if (!string.IsNullOrEmpty(request.Key))
{
UserTep user = UserTep.FromApiKey(context, request.Key);
datapackages.UserId = user.Id;
context.AccessLevel = EntityAccessLevel.Privilege;
}
datapackages.SetFilter("Kind", RemoteResourceSet.KINDRESOURCESETNORMAL.ToString());
// Load the complete request
HttpRequest httpRequest = HttpContext.Current.Request;
OpenSearchEngine ose = MasterCatalogue.OpenSearchEngine;
// the opensearch cache system uses the query parameters
// we add to the parameters the filters added to the load in order to avoir wrong cache
// we use 't2-' in order to not interfer with possibly used query parameters
var qs = new NameValueCollection(Request.QueryString);
foreach (var filter in datapackages.FilterValues)
{
qs.Add("t2-" + filter.Key.FieldName, filter.Value.ToString());
}
if (qs["visibility"] != null && qs["visibility"] != "all")
{
datapackages.AccessLevel = EntityAccessLevel.Privilege;
}
if (context.UserLevel == UserLevel.Administrator && (qs["visibility"] == null || qs["visibility"] != "owned"))
{
datapackages.SetFilter("Identifier", "!_index_*,!_series_*,!_products_*");
}
Type type = OpenSearchFactory.ResolveTypeFromRequest(httpRequest.QueryString, httpRequest.Headers, ose);
result = ose.Query(datapackages, qs, type);
context.Close();
} catch (Exception e) {
context.LogError(this, e.Message, e);
context.Close();
throw e;
}
return(new HttpResult(result.SerializeToString(), result.ContentType));
}
private IOpenSearchResultCollection GetActivityResultCollection(EntityList <Activity> activities)
{
// Load the complete request
HttpRequest httpRequest = HttpContext.Current.Request;
OpenSearchEngine ose = MasterCatalogue.OpenSearchEngine;
Type responseType = OpenSearchFactory.ResolveTypeFromRequest(httpRequest.QueryString, httpRequest.Headers, ose);
IOpenSearchResultCollection osr = ose.Query(activities, httpRequest.QueryString, responseType);
OpenSearchFactory.ReplaceOpenSearchDescriptionLinks(activities, osr);
return(osr);
}
private void QueryEarthObservationResult(ref IOpenSearchResultCollection osr)
{
foreach ( var item in osr.Items){
log.DebugFormat("Searching for alternate link to om for item {0}", item.Identifier);
var eo = Terradue.Metadata.EarthObservation.MetadataHelpers.GetEarthObservationFromIOpenSearchResultItem(item);
if (eo != null && eo is ServiceModel.Ogc.Eop20.EarthObservationType) {
AddOrReplaceEarthObservation((ServiceModel.Ogc.Eop20.EarthObservationType)eo, item);
}
}
}
private void QueryEarthObservationResult(ref IOpenSearchResultCollection osr)
{
foreach (var item in osr.Items)
{
log.DebugFormat("Searching for alternate link to om for item {0}", item.Identifier);
var eo = Terradue.Metadata.EarthObservation.OpenSearch.Extensions.EarthObservationOpenSearchResultExtensions.GetEarthObservationProfile(item);
if (eo != null && eo is ServiceModel.Ogc.Eop20.EarthObservationType)
{
AddOrReplaceEarthObservation((ServiceModel.Ogc.Eop20.EarthObservationType)eo, item);
}
}
}
private int CountResults(IOpenSearchResultCollection osr)
{
if (osr is IOpenSearchResultCollection)
{
IOpenSearchResultCollection rc = (IOpenSearchResultCollection)osr;
return(rc.Items.Count());
}
if (osr is SyndicationFeed)
{
SyndicationFeed feed = (SyndicationFeed)osr;
return(feed.Items.Count());
}
return(0);
}
public object Put(WpsJobUpdateRequestTep request)
{
var context = TepWebContext.GetWebContext(PagePrivileges.UserView);
context.Open();
context.LogInfo(this, string.Format("/job/wps PUT Id='{0}'", request.Id));
WpsJob job = WpsJob.FromIdentifier(context, request.Identifier);
try{
job.Name = request.Name;
job.Store();
context.LogDebug(this, string.Format("WpsJob '{0}' updated", job.Name));
}catch (Exception e) {
throw e;
}
EntityList <WpsJob> wpsjobs = new EntityList <WpsJob>(context);
wpsjobs.ItemVisibility = EntityItemVisibility.OwnedOnly;
wpsjobs.Load();
OpenSearchEngine ose = MasterCatalogue.OpenSearchEngine;
string format;
if (Request.QueryString["format"] == null)
{
format = "atom";
}
else
{
format = Request.QueryString["format"];
}
NameValueCollection nvc = new NameValueCollection();
nvc.Add("id", job.Identifier);
Type responseType = OpenSearchFactory.ResolveTypeFromRequest(HttpContext.Current.Request.QueryString, HttpContext.Current.Request.Headers, ose);
IOpenSearchResultCollection osr = ose.Query(wpsjobs, nvc, responseType);
OpenSearchFactory.ReplaceOpenSearchDescriptionLinks(wpsjobs, osr);
context.Close();
return(new HttpResult(osr.SerializeToString(), osr.ContentType));
}
public object Get(WpsJobSearchRequestTep request)
{
var context = TepWebContext.GetWebContext(PagePrivileges.EverybodyView);
context.Open();
context.LogInfo(this, string.Format("/job/wps/search GET"));
EntityList <WpsJob> wpsjobs = new EntityList <WpsJob>(context);
wpsjobs.AddSort("Id", SortDirection.Descending);
wpsjobs.IncludeOwnerFieldsInSearch = true;
// Load the complete request
HttpRequest httpRequest = HttpContext.Current.Request;
var qs = new NameValueCollection(httpRequest.QueryString);
OpenSearchEngine ose = MasterCatalogue.OpenSearchEngine;
if (qs["visibility"] != null && qs["visibility"] != "all")
{
wpsjobs.AccessLevel = EntityAccessLevel.Privilege;
}
if (!string.IsNullOrEmpty(qs["key"]))
{
try{
UserTep user = UserTep.FromApiKey(context, qs["key"]);
wpsjobs.UserId = user.Id;
context.AccessLevel = EntityAccessLevel.Privilege;
}catch (Exception) {}
}
if (string.IsNullOrEmpty(qs["id"]) && string.IsNullOrEmpty(qs["uid"]) && string.IsNullOrEmpty(qs["archivestatus"]))
{
qs.Set("archivestatus", (int)WpsJobArchiveStatus.NOT_ARCHIVED + "");
}
Type responseType = OpenSearchFactory.ResolveTypeFromRequest(httpRequest.QueryString, httpRequest.Headers, ose);
IOpenSearchResultCollection osr = ose.Query(wpsjobs, qs, responseType);
OpenSearchFactory.ReplaceOpenSearchDescriptionLinks(wpsjobs, osr);
// OpenSearchFactory.ReplaceSelfLinks(wpsjobs, httpRequest.QueryString, osr.Result, EntrySelfLinkTemplate);
context.Close();
return(new HttpResult(osr.SerializeToString(), osr.ContentType));
}
public BulkOperationsResponse Ingest(IOpenSearchableElasticType type, IHttpRequest request)
{
OpenSearchEngine ose = type.GetOpenSearchEngine(new NameValueCollection());
IOpenSearchEngineExtension osee = ose.GetExtensionByContentTypeAbility(request.ContentType);
if (osee == null)
{
throw new NotImplementedException(string.Format("No OpenSearch extension found for reading {0}", Request.ContentType));
}
MemoryOpenSearchResponse payload = new MemoryOpenSearchResponse(request.GetRawBody(), request.ContentType);
IOpenSearchResultCollection results = osee.ReadNative(payload);
return(Ingest(type, results));
}
public void SearchTwitterFeeds()
{
var ose = MasterCatalogue.OpenSearchEngine;
var settings = new OpenSearchableFactorySettings(ose);
var parameters = new NameValueCollection();
parameters.Set("count", "20");
try {
var twitters = TwitterNews.LoadTwitterCollection(context);
IOpenSearchResultCollection osr = ose.Query(twitters, parameters);
Assert.That(osr.TotalResults > 0);
} catch (Exception e) {
Assert.Fail(e.Message);
} finally {
context.EndImpersonation();
}
}
public static IElasticCollection CreateFromOpenSearchResultCollection(IOpenSearchResultCollection results)
{
if (results is GenericJsonCollection)
{
return((GenericJsonCollection)results);
}
GenericJsonCollection collection = new GenericJsonCollection();
collection.links = results.Links;
foreach (IOpenSearchResultItem result in results.Items)
{
var item = GenericJsonItem.FromOpenSearchResultItem(result);
collection.items.Add(item);
}
return(collection);
}
protected virtual IEnumerable <IMetric> AnalyzeResults(IOpenSearchResultCollection results, FiltersDefinition fd)
{
List <IMetric> metrics = new List <IMetric>();
long errors = 0;
if (results.Items.Count() > 0)
{
log.DebugFormat("[{1}] Validating {0} result items...", results.Items.Count(), Task.CurrentId);
}
foreach (var item in results.Items)
{
bool error = false;
foreach (var filterDefinition in fd.GetFilters())
{
if (filterDefinition.ItemValidator != null)
{
if (filterDefinition.ItemValidator.Invoke(item))
{
continue;
}
error = true;
log.WarnFormat("[{2}] Non expected item {0} with filter {1}", item.Identifier, filterDefinition.Label, Task.CurrentId);
}
if (filterDefinition.ResultsValidator != null)
{
if (filterDefinition.ResultsValidator.Invoke(results))
{
continue;
}
error = true;
log.WarnFormat("[{2}] Non expected results {0} with filter {1}", results.Identifier, filterDefinition.Label, Task.CurrentId);
}
}
if (error)
{
errors++;
}
}
metrics.Add(new LongMetric(MetricName.wrongResultsCount, errors, "#"));
return(metrics);
}
/// <summary>
/// Get the specified request.
/// </summary>
/// <param name="request">Request.</param>
public object Get(GetOpensearchSearch request)
{
var context = TepWebContext.GetWebContext(PagePrivileges.EverybodyView);
IOpenSearchResultCollection result = null;
try{
context.Open();
context.LogInfo(this, string.Format("/data/collection/{{serieId}}/search GET serieId='{0}'", request.serieId));
// Load the complete request
HttpRequest httpRequest = HttpContext.Current.Request;
if (request.serieId == null)
{
throw new ArgumentNullException(Terradue.Tep.WebServer.CustomErrorMessages.WRONG_IDENTIFIER);
}
Terradue.Tep.Collection serie = Terradue.Tep.Collection.FromIdentifier(context, request.serieId);
OpenSearchEngine ose = MasterCatalogue.OpenSearchEngine;
ose.DefaultTimeOut = 60000;
Type type = OpenSearchFactory.ResolveTypeFromRequest(httpRequest.QueryString, httpRequest.Headers, ose);
result = ose.Query(serie, httpRequest.QueryString, type);
var descriptionUrl = serie.GetDescriptionBaseUrl("application/opensearchdescription+xml");
if (descriptionUrl != null)
{
result.Links.Add(new SyndicationLink(new Uri(descriptionUrl.Template), descriptionUrl.Relation, "OpenSearch Description link", descriptionUrl.Type, 0));
}
MasterCatalogue.ReplaceSelfLinksFormat(result, Request.QueryString);
context.Close();
}catch (Exception e) {
context.LogError(this, e.Message, e);
context.Close();
throw e;
}
return(new HttpResult(result.SerializeToString(), result.ContentType));
}
public void SearchWpsJobsByIdentifier()
{
context.AccessLevel = EntityAccessLevel.Privilege;
var usr1 = User.FromUsername(context, "testusr1");
try {
context.StartImpersonation(usr1.Id);
EntityList <WpsJob> wpsjobs = new EntityList <WpsJob>(context);
var parameters = new NameValueCollection();
parameters.Set("uid", "private-job-usr1");
IOpenSearchResultCollection osr = ose.Query(wpsjobs, parameters);
Assert.AreEqual(NBJOBS_USR1_PRIVATE, osr.TotalResults);
} catch (Exception e) {
Assert.Fail(e.Message);
} finally {
context.EndImpersonation();
}
}
public RdfXmlDocument(IOpenSearchResultCollection results) : base() {
if (results.Title != null)
Title = results.Title;
else
Title = new TextSyndicationContent("");
Identifier = results.Identifier;
Id = results.Id;
duration = results.QueryTimeSpan;
openSearchable = results.OpenSearchable;
elementExtensions = results.ElementExtensions;
TotalResults = results.TotalResults;
Links = results.Links;
Authors = results.Authors;
LastUpdatedTime = results.LastUpdatedTime;
if (results.Items != null) {
items = new List<RdfXmlResult>();
foreach (var item in results.Items) {
var newItem = new RdfXmlResult(item);
newItem.Parent = this;
items.Add(newItem);
}
}
series = new XElement(dclite4gns + "Series",
new XElement(dcns + "identifier", Identifier),
new XElement(dcns + "title", Title.Text),
new XAttribute(rdfns + "about", Id)
);
}
/// <summary> /// Applies the result filters. /// </summary> /// <param name="osr">Osr.</param> /// <param name="originalParameters">Original parameters.</param> public abstract void ApplyResultFilters(ref IOpenSearchResultCollection osr, NameValueCollection originalParameters, IOpenSearchable entity);
public void ApplyResultFilters(OpenSearchRequest request, ref IOpenSearchResultCollection osr, string finalContentType)
{
}
private void QueryEarthObservationResult(ref IOpenSearchResultCollection osr)
{
foreach (var item in osr.Items)
{
log.DebugFormat("Searching for alternate link to metadata URL for item {0}", item.Identifier);
var altlink = item.Links.FirstOrDefault(l => l.RelationshipType == "via" && l.Title == "Original source metadata");
string identifier = null;
if (altlink != null)
{
log.DebugFormat("Link found at {0}", altlink.Uri);
var req = HttpWebRequest.Create(altlink.Uri);
log.DebugFormat("Query {0}...", altlink.Uri);
var response = req.GetResponse();
using (var xr = XmlReader.Create(response.GetResponseStream()))
{
while (xr.Read())
{
if (xr.LocalName == "scene" && xr.NamespaceURI == "http://earthexplorer.usgs.gov/eemetadata.xsd")
{
log.DebugFormat("Found scene metadata, harvesting {0} ...", altlink.Uri);
Terradue.OpenSearch.Model.Schemas.EarthExplorer.scene eescene = (Terradue.OpenSearch.Model.Schemas.EarthExplorer.scene)eeSer.Deserialize(xr);
Terradue.ServiceModel.Ogc.Eop21.EarthObservationType eo = EarthExplorerToEo(eescene);
AddIMGOffering(eo, item);
if (eo != null)
{
log.DebugFormat("EOP extension created from {0}", altlink.Uri);
using (MemoryStream stream = new MemoryStream())
{
XmlWriter writer = XmlWriter.Create(stream);
var ser = OgcHelpers.GetXmlSerializerFromType(eo.GetType());
ser.Serialize(stream, eo);
writer.Flush();
stream.Seek(0, SeekOrigin.Begin);
item.ElementExtensions.Add(XmlReader.Create(stream));
}
identifier = eo.EopMetaDataProperty.EarthObservationMetaData.identifier;
item.Title = new ServiceModel.Syndication.TextSyndicationContent(
string.Format("{0}, {1}, Path: {2}, Row: {3}",
identifier,
DateTime.Parse(eo.phenomenonTime.GmlTimePeriod.beginPosition.Value).ToString("yy-MMM-dd hh:mm:ss"),
eo.procedure.Eop21EarthObservationEquipment.acquisitionParameters.Acquisition.wrsLongitudeGrid.Value,
eo.procedure.Eop21EarthObservationEquipment.acquisitionParameters.Acquisition.wrsLatitudeGrid.Value
));
}
continue;
}
}
}
}
var identifierext = item.ElementExtensions.FirstOrDefault(e => e.OuterName == "identifier" && e.OuterNamespace == "http://purl.org/dc/elements/1.1/");
if (identifier == null)
{
UriBuilder url = new UriBuilder(identifierext.GetObject<string>());
NameValueCollection nvc = System.Web.HttpUtility.ParseQueryString(url.Query);
identifier = nvc["uid"];
if (identifier.Contains(":"))
identifier = identifier.Split(':')[1];
}
item.ElementExtensions.Remove(identifierext);
item.ElementExtensions.Add("identifier", "http://purl.org/dc/elements/1.1/", identifier);
}
}
/// <summary>
/// Gets the enclosures.
/// </summary>
/// <returns>The enclosures.</returns>
/// <param name="result">Result.</param>
public SyndicationLink[] GetEnclosures(IOpenSearchResultCollection result)
{
Type type = result.GetType();
IOpenSearchEngineExtension osee = GetFirstExtensionByTypeAbility(type);
if (osee == null)
throw new InvalidOperationException("No registered extensions able to get media enclosures for " + type.ToString());
return OpenSearchFactory.GetEnclosures(result);
}
public IElasticCollection FromOpenSearchResultCollection(IOpenSearchResultCollection results)
{
return CreateFromOpenSearchResultCollection(results);
}
void OutputResult(IOpenSearchResultCollection osr, Stream outputStream)
{
if (metadataPaths == null)
{
StreamWriter sw = new StreamWriter(outputStream);
if (osr is IOpenSearchResultCollection)
{
IOpenSearchResultCollection rc = (IOpenSearchResultCollection)osr;
foreach (var item in rc.Items)
{
var link = item.Links.FirstOrDefault(l => l.RelationshipType == "self");
if (link != null)
sw.WriteLine(link.Uri.ToString());
else
sw.WriteLine(item.Id);
}
sw.Flush();
}
return;
}
dataModel.LoadResults(osr);
if (metadataPaths.Contains("{}"))
{
dataModel.PrintCollection(outputStream);
return;
}
dataModel.PrintByItem(metadataPaths, outputStream);
return;
}
public static IOpenSearchResultCollection CreateFromOpenSearchResultCollection(IOpenSearchResultCollection results)
{
if (results == null)
throw new ArgumentNullException("results");
AtomFeed feed = new AtomFeed(new SyndicationFeed());
feed.Id = results.Id;
feed.Identifier = results.Identifier;
feed.Title = results.Title;
foreach ( var author in results.Authors ){
feed.Authors.Add(author);
}
if ( results.ElementExtensions != null )
feed.ElementExtensions = new SyndicationElementExtensionCollection(results.ElementExtensions);
if ( results.LastUpdatedTime.Ticks > 0 )
feed.LastUpdatedTime = results.LastUpdatedTime;
feed.Links = new Collection<SyndicationLink>(results.Links);
if (results.Items != null) {
List<AtomItem> items = new List<AtomItem>();
foreach (var item in results.Items) {
items.Add(AtomItem.FromOpenSearchResultItem(item));
}
feed.Items = items;
}
feed.QueryTimeSpan = results.QueryTimeSpan;
feed.OpenSearchable = results.OpenSearchable;
feed.TotalResults = results.TotalResults;
return feed;
}
public static void RemoveLinksByRel(ref IOpenSearchResultCollection results, string relType)
{
var matchLinks = results.Links.Where(l => l.RelationshipType == relType).ToArray();
foreach (var link in matchLinks) {
results.Links.Remove(link);
}
foreach (IOpenSearchResultItem item in results.Items) {
matchLinks = item.Links.Where(l => l.RelationshipType == relType).ToArray();
foreach (var link in matchLinks) {
item.Links.Remove(link);
}
}
}
public OpenSearchResult(IOpenSearchResultCollection result, NameValueCollection searchParameters)
{
Result = result;
this.searchParameters = searchParameters;
}
public FeatureCollectionResult ImportResults(IOpenSearchResultCollection results)
{
if (results == null)
throw new ArgumentNullException("results");
FeatureCollectionResult fc = new FeatureCollectionResult();
fc.Properties = new Dictionary<string, object>();
NameValueCollection namespaces = null;
XmlNamespaceManager xnsm = null;
string prefix = "";
List<XmlElement> elements = new List<XmlElement>();
foreach (var element in results.ElementExtensions) {
elements.Add(element.GetObject<XmlElement>());
}
if (options.KeepNamespaces) {
// Initialize namespaces
namespaces = new NameValueCollection();
namespaces.Set("", "http://geojson.org/ns#");
namespaces.Set("atom", "http://www.w3.org/2005/Atom");
foreach (var elem in results.ElementExtensions) {
XmlReader reader = elem.GetReader();
XmlDocument doc = new XmlDocument();
doc.Load(reader);
xnsm = new XmlNamespaceManager(doc.NameTable);
foreach (var names in xnsm.GetNamespacesInScope(XmlNamespaceScope.All)) {
namespaces.Set(names.Key, names.Value);
}
}
fc.Properties.Add("@namespaces", namespaces);
prefix = "atom:";
}
fc.Properties = fc.Properties.Concat(util.ImportXmlDocument(elements.ToArray(), ref namespaces)).ToDictionary(x => x.Key, x => x.Value);
if (results.Date != null && fc.Properties.ContainsKey(prefix + "updated") == null)
fc.Properties.Add(prefix + "updated", results.Date.ToString("yyyy'-'MM'-'dd'T'HH':'mm':'ss'Z'"));
if (results.Links != null && results.Links.Count > 0) {
fc.Links = results.Links;
}
if (options.KeepNamespaces == true && fc.Properties.ContainsKey("dc:identifier") == null) {
namespaces.Set("dc", "http://purl.org/dc/elements/1.1/");
fc.Properties.Add("dc:identifier", results.Identifier);
}
if (options.KeepNamespaces == false && fc.Properties.ContainsKey("identifier") == null) {
fc.Properties.Add("identifier", results.Identifier);
}
if (results.Items != null) {
foreach (var item in results.Items) {
fc.FeatureResults.Add(ImportItem(item));
}
}
return fc;
}
public static void ReplaceSelfLinks(IOpenSearchable entity, NameValueCollection parameters, IOpenSearchResultCollection osr, Func<IOpenSearchResultItem,OpenSearchDescription,string,string> entryTemplate, string contentType)
{
IOpenSearchResultCollection feed = osr;
var matchLinks = feed.Links.Where(l => l.RelationshipType == "self").ToArray();
foreach (var link in matchLinks) {
feed.Links.Remove(link);
}
OpenSearchDescription osd = null;
if (entity is IProxiedOpenSearchable) {
osd = ((IProxiedOpenSearchable)entity).GetProxyOpenSearchDescription();
} else {
osd = entity.GetOpenSearchDescription();
}
if (OpenSearchFactory.GetOpenSearchUrlByType(osd, contentType) == null)
return;
NameValueCollection newNvc = new NameValueCollection(parameters);
NameValueCollection osparams = OpenSearchFactory.GetOpenSearchParameters(OpenSearchFactory.GetOpenSearchUrlByType(osd, contentType));
newNvc.AllKeys.FirstOrDefault(k => {
if (string.IsNullOrEmpty(OpenSearchFactory.GetParamNameFromId(osparams, k)))
newNvc.Remove(k);
return false;
});
osparams.AllKeys.FirstOrDefault(k => {
Match matchParamDef = Regex.Match(osparams[k], @"^{([^?]+)\??}$");
if (!matchParamDef.Success)
newNvc.Set(k, osparams[k]);
return false;
});
UriBuilder myUrl = new UriBuilder(OpenSearchFactory.GetOpenSearchUrlByType(osd, contentType).Template);
string[] queryString = Array.ConvertAll(newNvc.AllKeys, key => string.Format("{0}={1}", key, newNvc[key]));
myUrl.Query = string.Join("&", queryString);
feed.Links.Add(new SyndicationLink(myUrl.Uri, "self", "Reference link", contentType, 0));
feed.Id = myUrl.ToString();
foreach (IOpenSearchResultItem item in feed.Items) {
matchLinks = item.Links.Where(l => l.RelationshipType == "self").ToArray();
foreach (var link in matchLinks) {
item.Links.Remove(link);
}
string template = entryTemplate(item, osd, contentType);
if (template != null) {
item.Links.Add(new SyndicationLink(new Uri(template), "self", "Reference link", contentType, 0));
item.Id = template;
}
}
}
public static void ReplaceSelfLinks(IOpenSearchable entity, NameValueCollection parameters, IOpenSearchResultCollection osr, Func<IOpenSearchResultItem,OpenSearchDescription,string,string> entryTemplate)
{
ReplaceSelfLinks(entity, parameters, osr, entryTemplate, osr.ContentType);
}
public static void ReplaceOpenSearchDescriptionLinks(IOpenSearchable entity, IOpenSearchResultCollection osr)
{
IOpenSearchResultCollection feed = osr;
var matchLinks = feed.Links.Where(l => l.RelationshipType == "search").ToArray();
foreach (var link in matchLinks) {
feed.Links.Remove(link);
}
OpenSearchDescription osd;
if (entity is IProxiedOpenSearchable)
osd = ((IProxiedOpenSearchable)entity).GetProxyOpenSearchDescription();
else
osd = entity.GetOpenSearchDescription();
OpenSearchDescriptionUrl url = OpenSearchFactory.GetOpenSearchUrlByRel(osd, "self");
Uri uri;
if (url != null)
uri = new Uri(url.Template);
else
uri = osd.Originator;
if (uri != null)
feed.Links.Add(new SyndicationLink(uri, "search", "OpenSearch Description link", "application/opensearchdescription+xml", 0));
}
public abstract void AddSearchLink(ref IOpenSearchResultCollection osr, NameValueCollection originalParameters, IOpenSearchable entity, string with, string finalContentType);
public IElasticCollection FromOpenSearchResultCollection(IOpenSearchResultCollection results)
{
return GenericJsonCollection.CreateFromOpenSearchResultCollection(results);
}
public BulkOperationsResponse Ingest(IOpenSearchableElasticType type, IOpenSearchResultCollection results)
{
OpenSearchFactory.RemoveLinksByRel(ref results, "self");
OpenSearchFactory.RemoveLinksByRel(ref results, "search");
IElasticCollection docs = type.FromOpenSearchResultCollection(results);
BulkRequest bulkRequest = new BulkRequest() {
Refresh = true,
Consistency = Consistency.One,
Index = type.Index,
Type = type.Type,
Operations = new List<IBulkOperation>()
};
RootObjectMapping currentMapping = null;
try {
var mappingResponse = client.GetMapping<IElasticType>(g => g.Index(type.Index.Name).Type(type.Type.Name));
currentMapping = mappingResponse.Mapping;
} catch (Exception) {
}
var rootObjectMapping = type.GetRootMapping();
if (!rootObjectMapping.Equals(currentMapping)) {
client.Map<IElasticType>(m => m.Index(type.Index.Name).Type(type.Type.Name));
}
foreach (var doc in docs.ElasticItems) {
var bulkIndexOperation = new BulkIndexOperation<IElasticItem>(doc);
bulkIndexOperation.Id = ((IOpenSearchResultItem)doc).Identifier;
bulkIndexOperation.Type = type.Type.Name;
var bulkOp = bulkIndexOperation;
bulkRequest.Operations.Add(bulkOp);
}
var response = client.Bulk(bulkRequest);
BulkOperationsResponse ingestionResponse = new BulkOperationsResponse();
foreach (var item in response.Items) {
if (!item.IsValid) {
ingestionResponse.Errors++;
continue;
}
if (item.Version == "1")
ingestionResponse.Added++;
else
ingestionResponse.Updated++;
}
return ingestionResponse;
}
public static SyndicationLink[] GetEnclosures(IOpenSearchResultCollection result)
{
List<SyndicationLink> links = new List<SyndicationLink>();
foreach (IOpenSearchResultItem item in result.Items) {
foreach (SyndicationLink link in item.Links) {
if (link.RelationshipType == "enclosure") {
links.Add(link);
}
}
}
return links.ToArray();
}
public void ApplyResultFilters(OpenSearchRequest request, ref IOpenSearchResultCollection osr)
{
OpenSearchFactory.ReplaceSelfLinks(this, request.Parameters, osr, this.EntrySelfLinkTemplate);
}
public void LoadOpenSearchResultCollection(Terradue.OpenSearch.Result.IOpenSearchResultCollection osr)
{
this.osr = osr;
}
public static FeatureCollectionResult FromOpenSearchResultCollection(IOpenSearchResultCollection results)
{
if (results == null)
throw new ArgumentNullException("results");
FeatureCollectionResult fc = new FeatureCollectionResult();
fc.ElementExtensions = new SyndicationElementExtensionCollection(results.ElementExtensions);
if (results.Links != null && results.Links.Count > 0) {
fc.Links = results.Links;
}
fc.authors = results.Authors;
fc.categories = results.Categories;
fc.LastUpdatedTime = results.LastUpdatedTime;
fc.Title = results.Title;
fc.TotalResults = results.TotalResults;
fc.OpenSearchable = results.OpenSearchable;
if (results.Items != null) {
foreach (var item in results.Items) {
fc.FeatureResults.Add(FeatureResult.FromOpenSearchResultItem(item));
}
}
return fc;
}
public static IOpenSearchResultCollection CreateFromOpenSearchResultCollection(IOpenSearchResultCollection results) {
if (results == null)
throw new ArgumentNullException("results");
RdfXmlDocument rdf = new RdfXmlDocument(results);
return rdf;
}
int CountResults(IOpenSearchResultCollection osr)
{
if (osr is IOpenSearchResultCollection)
{
IOpenSearchResultCollection rc = (IOpenSearchResultCollection)osr;
return rc.Items.Count();
}
if (osr is SyndicationFeed)
{
SyndicationFeed feed = (SyndicationFeed)osr;
return feed.Items.Count();
}
return 0;
}
void ApplyOpenSearchElements(ref IOpenSearchResultCollection newResults, OpenSearchRequest request, IOpenSearchResponse response)
{
foreach (SyndicationElementExtension ext in newResults.ElementExtensions.ToArray()) {
if (ext.OuterName == "startIndex" && ext.OuterNamespace == "http://a9.com/-/spec/opensearch/1.1/")
newResults.ElementExtensions.Remove(ext);
if (ext.OuterName == "itemsPerPage" && ext.OuterNamespace == "http://a9.com/-/spec/opensearch/1.1/")
newResults.ElementExtensions.Remove(ext);
if (ext.OuterName == "Query" && ext.OuterNamespace == "http://a9.com/-/spec/opensearch/1.1/")
newResults.ElementExtensions.Remove(ext);
}
newResults.ElementExtensions.Add("startIndex", "http://a9.com/-/spec/opensearch/1.1/", request.OpenSearchUrl.IndexOffset);
newResults.ElementExtensions.Add("itemsPerPage", "http://a9.com/-/spec/opensearch/1.1/", request.OpenSearchUrl.Count);
XElement query = new XElement(XName.Get("Query", "http://a9.com/-/spec/opensearch/1.1/"));
OpenSearchDescription osd = null;
if (response.Entity is IProxiedOpenSearchable)
osd = ((IProxiedOpenSearchable)response.Entity).GetProxyOpenSearchDescription();
else
osd = response.Entity.GetOpenSearchDescription();
foreach (var ns in osd.ExtraNamespace.ToArray()) {
if (string.IsNullOrEmpty(ns.Name) || ns.Namespace == "http://www.w3.org/2001/XMLSchema" || ns.Namespace == "http://www.w3.org/2001/XMLSchema-instance" || ns.Namespace == XNamespace.Xmlns.NamespaceName)
continue;
query.Add(new XAttribute(XNamespace.Xmlns + ns.Name, ns.Namespace));
}
var osUrl = OpenSearchFactory.GetOpenSearchUrlByType(osd, request.ContentType);
var osparams = OpenSearchFactory.GetOpenSearchParameters(osUrl);
foreach (var key in request.Parameters.AllKeys) {
string osparam = OpenSearchFactory.GetParamNameFromId(osparams, key);
if (!string.IsNullOrEmpty(osparam)) {
try {
if (osparam.Contains(":"))
query.Add(new XAttribute(XName.Get(osparam.Split(':')[1], osd.ExtraNamespace.ToArray().First(n => n.Name == osparam.Split(':')[0]).Namespace), request.Parameters[key]));
else {
query.Add(new XAttribute(XName.Get(osparam, osd.ExtraNamespace.ToArray().First(n => n.Name == "os").Namespace), request.Parameters[key]));
}
} catch {
}
}
}
newResults.ElementExtensions.Add(query.CreateReader());
}
public void LoadResults(IOpenSearchResultCollection osr)
{
modelExtension.LoadOpenSearchResultCollection(osr);
modelExtension.ApplyParameters();
}
public static IElasticCollection CreateFromOpenSearchResultCollection(IOpenSearchResultCollection results)
{
if (results is GenericJsonCollection)
return (GenericJsonCollection)results;
GenericJsonCollection collection = new GenericJsonCollection();
collection.links = results.Links;
foreach (IOpenSearchResultItem result in results.Items) {
var item = GenericJsonItem.FromOpenSearchResultItem(result);
collection.items.Add(item);
}
return collection;
}
