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();
}
}
//---------------------------------------------------------------------------------------------------------------------
#region IOpenSearchable implementation
//---------------------------------------------------------------------------------------------------------------------
public OpenSearchRequest Create(QuerySettings querySettings, System.Collections.Specialized.NameValueCollection parameters)
{
UriBuilder url = new UriBuilder(context.BaseUrl);
url.Path += "/remoteresource/" + this.Identifier;
var array = (from key in parameters.AllKeys
from value in parameters.GetValues(key)
select string.Format("{0}={1}", HttpUtility.UrlEncode(key), HttpUtility.UrlEncode(value)))
.ToArray();
url.Query = string.Join("&", array);
/*if (!String.IsNullOrEmpty(parameters["grouped"]) && parameters["grouped"] == "true") {
* return new MultiAtomGroupedOpenSearchRequest(ose, GetOpenSearchableArray(), type, new OpenSearchUrl(url.ToString()), true);
* }*/
//TODO: if only one result dont use Multi
var entities = GetOpenSearchableArray();
OpenSearchableFactorySettings settings = new OpenSearchableFactorySettings(ose)
{
Credentials = querySettings.Credentials
};
settings.MergeFilters = Terradue.Metadata.EarthObservation.Helpers.GeoTimeOpenSearchHelper.MergeGeoTimeFilters;
return(new MultiOpenSearchRequest <AtomFeed, AtomItem>(settings, entities, querySettings.PreferredContentType, new OpenSearchUrl(url.ToString()), true, this));
}
public UrlBasedOpenSearchable(IfyContext context, OpenSearchDescription osd, OpenSearchUrl url, OpenSearchableFactorySettings settings)
{
this.context = context;
this.osd = osd;
this.url = url;
this.settings = settings;
}
internal IOpenSearchable CreateOpenSearchableEntity(FiltersDefinition filters = null, int maxRetries = 3)
{
OpenSearchableFactorySettings ossettings = new OpenSearchableFactorySettings(ose)
{
Credentials = Wrapper.Settings.Credentials,
MaxRetries = maxRetries
};
IDataHubSourceWrapper wrapper = CreateDataAccessWrapper(TargetSiteConfig, filters);
wrapper.Settings.MaxRetries = 3;
return(wrapper.CreateOpenSearchable(ossettings));
}
//---------------------------------------------------------------------------------------------------------------------
public virtual IOpenSearchable[] GetOpenSearchableArray()
{
List <IOpenSearchable> osResources = new List <IOpenSearchable>(Resources.Count);
var settings = new OpenSearchableFactorySettings(ose);
settings.MergeFilters = Terradue.Metadata.EarthObservation.Helpers.GeoTimeOpenSearchHelper.MergeGeoTimeFilters;
foreach (RemoteResource res in Resources)
{
var entity = OpenSearchFactory.FindOpenSearchable(settings, new Uri(res.Location));
osResources.Add(entity);
}
return(osResources.ToArray());
}
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 OpenSearchRequest Create(QuerySettings querySettings, NameValueCollection parameters)
{
UriBuilder url = new UriBuilder(context.BaseUrl);
url.Path += "/series/" + this.Identifier;
var array = (from key in parameters.AllKeys
from value in parameters.GetValues(key)
select string.Format("{0}={1}", HttpUtility.UrlEncode(key), HttpUtility.UrlEncode(value)))
.ToArray();
url.Query = string.Join("&", array);
OpenSearchableFactorySettings settings = new OpenSearchableFactorySettings(ose)
{
Credentials = querySettings.Credentials
};
settings.MergeFilters = Terradue.Metadata.EarthObservation.Helpers.GeoTimeOpenSearchHelper.MergeGeoTimeFilters;
return(new MultiOpenSearchRequest <AtomFeed, AtomItem>(settings, Series.ToArray(), querySettings.PreferredContentType, new OpenSearchUrl(url.ToString()), true, this));
}
public virtual IOpenSearchable CreateOpenSearchable(IEnumerable <Uri> baseUrls, string queryFormatArg, OpenSearchEngine ose, IEnumerable <NetworkCredential> netCreds, OpenSearchableFactorySettings settings)
{
List <IOpenSearchable> entities = new List <IOpenSearchable>();
for (int i = 0; i < baseUrls.Count(); i++)
{
var url = baseUrls.ElementAt(i);
settings.Credentials = netCreds == null ? null : netCreds.ElementAt(i);
if (string.IsNullOrEmpty(queryFormatArg))
{
try
{
entities.Add(OpenSearchFactory.FindOpenSearchable(settings, url, null));
}
catch (Exception e)
{
throw e;
}
}
else
{
var e = OpenSearchFactory.FindOpenSearchable(settings, url, ose.GetExtensionByExtensionName(queryFormatArg).DiscoveryContentType);
entities.Add(e);
}
}
IOpenSearchable entity;
OpenSearchableFactorySettings settings2 = new OpenSearchableFactorySettings(ose);
if (entities.Count > 1)
{
entity = new MultiGenericOpenSearchable(entities, settings2);
}
else
{
entity = entities[0];
}
return(entity);
}
public object Get(WpsJobProductSearchRequestTep request)
{
var context = TepWebContext.GetWebContext(PagePrivileges.EverybodyView);
HttpResult result = null;
try {
context.Open();
context.LogInfo(this, string.Format("/job/wps/{0}/products/search GET", request.JobId));
WpsJob wpsjob = null;
try {
wpsjob = WpsJob.FromIdentifier(context, request.JobId);
} catch (Exception e) {
if (request.Key != null) //or if public
{
context.AccessLevel = EntityAccessLevel.Administrator;
wpsjob = WpsJob.FromIdentifier(context, request.JobId);
if (request.Key != null && !request.Key.Equals(wpsjob.AccessKey))
{
throw new UnauthorizedAccessException(CustomErrorMessages.WRONG_ACCESSKEY);
}
}
else
{
throw e;
}
}
OpenSearchEngine ose = MasterCatalogue.OpenSearchEngine;
HttpRequest httpRequest = HttpContext.Current.Request;
Type type = OpenSearchFactory.ResolveTypeFromRequest(httpRequest.QueryString, httpRequest.Headers, ose);
var nvc = httpRequest.QueryString;
if (CatalogueFactory.IsCatalogUrl(new Uri(wpsjob.StatusLocation)))
{
var settings = MasterCatalogue.OpenSearchFactorySettings;
OpenSearchableFactorySettings specsettings = (OpenSearchableFactorySettings)settings.Clone();
//get credentials from current user
if (context.UserId != 0)
{
var user = UserTep.FromId(context, context.UserId);
var apikey = user.GetSessionApiKey();
var t2userid = user.TerradueCloudUsername;
if (!string.IsNullOrEmpty(apikey))
{
specsettings.Credentials = new System.Net.NetworkCredential(t2userid, apikey);
}
}
GenericOpenSearchable urlToShare = new GenericOpenSearchable(new OpenSearchUrl(wpsjob.StatusLocation), specsettings);
var res = ose.Query(urlToShare, nvc, type);
result = new HttpResult(res.SerializeToString(), res.ContentType);
}
else
{
WpsJobProductOpenSearchable wpsjobProductOs = new WpsJobProductOpenSearchable(wpsjob, context);
//var nvc = wpsjobUrl.GetParameters ();
var res = ose.Query(wpsjobProductOs, nvc, type);
OpenSearchFactory.ReplaceSelfLinks(wpsjobProductOs, httpRequest.QueryString, res, EntrySelfLinkTemplate);
OpenSearchFactory.ReplaceOpenSearchDescriptionLinks(wpsjobProductOs, res);
result = new HttpResult(res.SerializeToString(), res.ContentType);
}
context.Close();
} catch (Exception e) {
context.LogError(this, e.Message, e);
context.Close();
throw e;
}
return(result);
}
private SandboxOpenSearchable(SandboxOpenSearchInformation sosi, OpenSearchableFactorySettings settings) : base(sosi.Url, settings)
{
this.SandboxOpenSearchInformation = sosi;
}
public override IOpenSearchable[] GetOpenSearchableArray()
{
List <IOpenSearchable> osResources = new List <IOpenSearchable>(Resources.Count);
var settings = MasterCatalogue.OpenSearchFactorySettings;
string apikey = null;
string t2userid = null;
if (context.UserId != 0)
{
var user = UserTep.FromId(context, context.UserId);
apikey = user.GetSessionApiKey();
t2userid = user.TerradueCloudUsername;
}
foreach (RemoteResource res in Resources)
{
OpenSearchableFactorySettings specsettings = (OpenSearchableFactorySettings)settings.Clone();
// For Terradue resources, use the API key
if (res.Location.StartsWith(context.GetConfigValue("catalog-baseurl")) && !string.IsNullOrEmpty(apikey))
{
specsettings.Credentials = new System.Net.NetworkCredential(t2userid, apikey);
}
try {
IOpenSearchable entity = null;
try {
entity = OpenSearchFactory.FindOpenSearchable(specsettings, new Uri(res.Location), "application/atom+xml");
}catch (Exception e) {
if (!res.Location.StartsWith(context.GetConfigValue("catalog-baseurl")))
{
try {
entity = OpenSearchFactory.FindOpenSearchable(specsettings, new Uri(res.Location));
} catch (Exception ex) {
var feed = new AtomFeed();
feed.Id = "Exception";
feed.ElementExtensions.Add(
new SyndicationElementExtension("exception", "", new ExceptionMessage {
Message = ex.Message, Source = res.Location, HelpLink = ex.HelpLink
})
);
entity = new ExceptionOpensearchable(feed);
}
}
else
{
var feed = new AtomFeed();
feed.Id = "Exception";
feed.ElementExtensions.Add(
new SyndicationElementExtension("exception", "", new ExceptionMessage {
Message = e.Message, Source = res.Location, HelpLink = e.HelpLink
})
);
entity = new ExceptionOpensearchable(feed);
}
}
if (entity != null)
{
osResources.Add(entity);
}
}
catch (Exception e)
{
context.LogError(this, e.Message);
}
}
return(osResources.ToArray());
}
public override IOpenSearchable CreateOpenSearchable(IEnumerable <Uri> baseUrls, string queryFormatArg, OpenSearchEngine ose, IEnumerable <NetworkCredential> netCreds, OpenSearchableFactorySettings settings)
{
List <IOpenSearchable> entities = new List <IOpenSearchable>();
IOpenSearchEngineExtension ext;
if (string.IsNullOrEmpty(queryFormatArg))
{
ext = ose.GetExtensionByExtensionName("atom");
}
else
{
ext = ose.GetExtensionByExtensionName(queryFormatArg);
}
for (int i = 0; i < baseUrls.Count(); i++)
{
var url = baseUrls.ElementAt(i);
settings.Credentials = netCreds == null ? null : netCreds.ElementAt(i);
IOpenSearchable e = null;
// QC Sentinel1 case
if (url.Host == "qc.sentinel1.eo.esa.int")
{
log.DebugFormat("QC Sentinel1 source. Trying to get the earthobservation profile");
e = new Sentinel1QcOpenSearchable(url, settings.OpenSearchEngine);
entities.Add(e);
continue;
}
// USGS case
if (url.Host == "earthexplorer.usgs.gov")
{
log.DebugFormat("Usgs source. Trying to get the earthobservation profile");
// usgsOpenSearchable
e = new Terradue.OpenSearch.Usgs.UsgsOpenSearchable(url, settings);
entities.Add(e);
continue;
}
e = OpenSearchFactory.FindOpenSearchable(settings, url, ext.DiscoveryContentType);
if (!e.DefaultMimeType.Contains("profile=http://earth.esa.int/eop"))
{
try {
e = OpenSearchFactory.FindOpenSearchable(settings, url, "application/atom+xml; profile=http://earth.esa.int/eop/2.1");
} catch (InvalidOperationException) {
e = OpenSearchFactory.FindOpenSearchable(settings, url, "application/atom+xml");
}
if (!e.DefaultMimeType.Contains("xml"))
{
throw new InvalidOperationException("No Url in the OpenSearch Description Document that could fit the EOP data model");
}
}
// Fedeo case
if (url.Host == "fedeo.esa.int" && e.DefaultMimeType == "application/atom+xml" && e is Terradue.OpenSearch.GenericOpenSearchable)
{
log.DebugFormat("Fedeo source. Trying to get the earthobservation profile");
e = FedeoOpenSearchable.CreateFrom(url, settings.OpenSearchEngine);
}
// Cwic case
if (url.Host == "cwic.wgiss.ceos.org" && e.DefaultMimeType == "application/atom+xml" && e is Terradue.OpenSearch.GenericOpenSearchable)
{
log.DebugFormat("Cwic source. Trying to get the earthobservation profile");
e = CwicOpenSearchable.CreateFrom((Terradue.OpenSearch.GenericOpenSearchable)e, settings.OpenSearchEngine);
}
entities.Add(e);
}
IOpenSearchable entity;
OpenSearchableFactorySettings settings2 = new OpenSearchableFactorySettings(ose);
if (entities.Count > 1)
{
entity = new MultiGenericOpenSearchable(entities, settings2);
}
else
{
entity = entities[0];
}
return(entity);
}
public static SandboxOpenSearchable CreateSandboxOpenSearchable(OpenSearchUrl osUrl, OpenSearchableFactorySettings settings)
{
var sosi = GetSandboxOpenSearchInformation(osUrl);
return(new SandboxOpenSearchable(sosi, settings));
}
public object Get(ThematicAppCurrentUserSearchRequestTep request)
{
IfyWebContext context = TepWebContext.GetWebContext(PagePrivileges.EverybodyView);
context.Open();
context.LogInfo(this, string.Format("/user/current/apps/search GET"));
IOpenSearchResultCollection result;
OpenSearchEngine ose = MasterCatalogue.OpenSearchEngine;
var httpRequest = HttpContext.Current.Request;
Type responseType = OpenSearchFactory.ResolveTypeFromRequest(httpRequest.QueryString, httpRequest.Headers, ose);
List <Terradue.OpenSearch.IOpenSearchable> osentities = new List <Terradue.OpenSearch.IOpenSearchable>();
var settings = MasterCatalogue.OpenSearchFactorySettings;
OpenSearchableFactorySettings specsettings = (OpenSearchableFactorySettings)settings.Clone();
UserTep user = null;
if (context.UserId != 0)
{
user = UserTep.FromId(context, context.UserId);
if (request.cache)
{
var domain = user.GetPrivateDomain();
EntityList <ThematicApplicationCached> appsCached = new EntityList <ThematicApplicationCached>(context);
appsCached.SetFilter("DomainId", domain.Id);
appsCached.AddSort("LastUpdate", SortDirection.Descending);
result = ose.Query(appsCached, Request.QueryString, responseType);
OpenSearchFactory.ReplaceOpenSearchDescriptionLinks(appsCached, result);
}
else
{
//get user private thematic app
var apikey = user.GetSessionApiKey();
var t2userid = user.TerradueCloudUsername;
if (!string.IsNullOrEmpty(apikey))
{
specsettings.Credentials = new System.Net.NetworkCredential(t2userid, apikey);
}
var app = user.GetPrivateThematicApp();
if (app != null)
{
foreach (var item in app.Items)
{
if (!string.IsNullOrEmpty(item.Location))
{
try {
var sgOs = OpenSearchFactory.FindOpenSearchable(specsettings, new OpenSearchUrl(item.Location));
osentities.Add(sgOs);
context.LogDebug(this, string.Format("Apps search -- Add '{0}'", item.Location));
} catch (Exception e) {
context.LogError(this, e.Message, e);
}
}
}
}
MultiGenericOpenSearchable multiOSE = new MultiGenericOpenSearchable(osentities, specsettings);
result = ose.Query(multiOSE, Request.QueryString, responseType);
}
}
else
{
result = ose.Query(new MultiGenericOpenSearchable(osentities, specsettings), Request.QueryString, responseType);
}
string sresult = result.SerializeToString();
//replace usernames in apps
if (user != null)
{
try {
sresult = sresult.Replace("${USERNAME}", user.Username);
sresult = sresult.Replace("${T2USERNAME}", user.TerradueCloudUsername);
sresult = sresult.Replace("${T2APIKEY}", user.GetSessionApiKey());
} catch (Exception e) {
context.LogError(this, e.Message, e);
}
}
context.Close();
return(new HttpResult(sresult, result.ContentType));
}
public override IOpenSearchable CreateOpenSearchable(IEnumerable <Uri> baseUrls, string queryFormatArg, OpenSearchEngine ose, IEnumerable <NetworkCredential> netCreds, OpenSearchableFactorySettings settings)
{
if (netCreds == null || netCreds.Count() == 0)
{
throw new InvalidOperationException("Missing credentials for access Scihub service");
}
settings.Credentials = netCreds.First();
DataHubOpenSearchable entity = new DataHubOpenSearchable(baseUrls.First(), settings);
if (queryFormatArg == "eop")
{
entity.DefaultMimeType = "application/atom+xml; profile=http://earth.esa.int/eop/2.1";
}
return(entity);
}
private void PrintOpenSearchDescription(string arg)
{
Match argMatch = argRegex.Match(arg);
string type = argMatch.Groups[1].Value;
string paramName = (argMatch.Groups[2].Success ? argMatch.Groups[3].Value : null);
bool typeFound = false;
bool paramFound = false;
dataModelParameters = PrepareDataModelParameters();
dataModel = DataModel.CreateFromArgs(queryModelArg, dataModelParameters);
OpenSearchableFactorySettings settings = new OpenSearchableFactorySettings(ose);
settings.MaxRetries = retryAttempts;
List <Uri> baseUrls = InitializeUrl();
IOpenSearchable entity = dataModel.CreateOpenSearchable(baseUrls, queryFormatArg, ose, netCreds, settings);
OpenSearchDescription osd = entity.GetOpenSearchDescription();
using (Stream outputStream = InitializeOutputStream()) {
using (StreamWriter sw = new StreamWriter(outputStream)) {
if (type == "types")
{
sw.WriteLine("Formats");
sw.WriteLine("{0,-10}{1,-10}{2,-60}", "Format", "Supported", "MIME type");
sw.WriteLine("{0,-10}{1,-10}{2,-60}", "======", "=========", "=========");
foreach (OpenSearchDescriptionUrl url in osd.Url)
{
if (url.Relation == "self")
{
continue;
}
bool isFormat = false;
foreach (IOpenSearchEngineExtension osee in ose.Extensions.Values)
{
if (osee.DiscoveryContentType == url.Type)
{
isFormat = true;
break;
}
}
string urlShortType = GetUrlShortType(url.Type);
sw.WriteLine("{0,-14}{1,-6}{2,-40}", urlShortType == url.Type ? "-" : urlShortType, isFormat ? "*" : " ", url.Type);
}
}
else
{
foreach (OpenSearchDescriptionUrl url in osd.Url)
{
if (url.Relation == "self")
{
continue;
}
string urlShortType = GetUrlShortType(url.Type);
if (type != "full" && type != urlShortType)
{
continue;
}
typeFound = true;
bool isFormat = false;
foreach (IOpenSearchEngineExtension osee in ose.Extensions.Values)
{
if (osee.DiscoveryContentType == url.Type)
{
isFormat = true;
break;
}
}
sw.Write("Search URL type: {0}", url.Type);
if (isFormat)
{
sw.Write(" (format: {0})", urlShortType);
}
sw.WriteLine();
int qmPos = url.Template.IndexOf('?');
if (qmPos == -1)
{
continue;
}
string queryString = url.Template.Substring(qmPos + 1);
if (paramName == null)
{
sw.WriteLine("Parameters");
sw.WriteLine("{0,-22}{1,-40} M O R P S (mandatory, options, range, pattern, step)", "Name", "Description/title");
sw.WriteLine("{0,-22}{1,-40} ---------", "----", "-----------------");
}
MatchCollection paramMatches = paramRegex.Matches(queryString);
foreach (Match paramMatch in paramMatches)
{
string name = paramMatch.Groups[1].Value;
string identifier = paramMatch.Groups[2].Value;
bool mandatory = !paramMatch.Groups[3].Success;
string title = GetParameterDescription(identifier);
bool options = false;
bool range = false;
bool pattern = false;
bool step = false;
OpenSearchDescriptionUrlParameter param = null;
if (url.Parameters != null)
{
foreach (OpenSearchDescriptionUrlParameter p in url.Parameters)
{
if (p.Name == name)
{
param = p;
}
}
}
if (param != null)
{
title = param.Title;
options = param.Options != null && param.Options.Count != 0;
range = param.Maximum != null || param.MinInclusive != null || param.MaxInclusive != null || param.MinExclusive != null || param.MaxExclusive != null;
pattern = param.Pattern != null;
step = param.Step != null;
}
if (paramName == null)
{
if (title != null && title.Length > 40)
{
title = String.Format("{0}...", title.Substring(0, 37));
}
sw.WriteLine("- {0,-20}{1,-40} {2,-2}{3,-2}{4,-2}{5,-2}{6,-2}",
name,
title,
mandatory ? "M" : "-",
options ? "O" : "-",
range ? "R" : "-",
pattern ? "P" : "-",
step ? "S" : "-"
);
}
if (type != "full" && paramName != name)
{
continue;
}
paramFound = true;
if (paramName != null)
{
sw.WriteLine("- Parameter: {0}", name);
sw.WriteLine(" Description/title: {0}", title);
}
if (options)
{
sw.WriteLine(" Options:");
sw.WriteLine(" {0,-22} {1,-40}", "Value", "Label/description");
sw.WriteLine(" {0,-22} {1,-40}", "-----", "-----------------");
foreach (OpenSearchDescriptionUrlParameterOption o in param.Options)
{
sw.WriteLine(" - {0,-20} {1,-40}", o.Value, o.Label);
}
}
if (range)
{
string min = (param.MinExclusive != null ? param.MinExclusive : param.MinInclusive != null ? param.MinInclusive : param.Minimum);
string max = (param.MaxExclusive != null ? param.MaxExclusive : param.MaxInclusive != null ? param.MaxInclusive : param.Maximum);
sw.WriteLine(" Range: {0} {2} value {3} {1}", min, max, param.MinExclusive == null ? "<=" : "<", param.MaxExclusive == null ? "<=" : "<");
}
if (pattern)
{
sw.WriteLine(" Pattern: {0}", param.Pattern);
}
if (step)
{
sw.WriteLine(" Step: {0}", param.Step);
}
}
sw.WriteLine();
//sw.WriteLine("URL {0} {1} {2}", url.Type, url.Relation, url.Template);
}
}
sw.Close();
}
}
if (!typeFound && type != "types" && type != "full")
{
log.Error("URL Type not found");
}
else if (!paramFound && paramName != null)
{
log.Error("Parameter not found");
}
}
public UrlBasedOpenSearchableFactory(IfyContext context, OpenSearchableFactorySettings settings)
{
this.context = context;
Settings = (OpenSearchableFactorySettings)settings.Clone();
}
public IOpenSearchable CreateOpenSearchable(IEnumerable <Uri> baseUrls, string queryFormatArg, OpenSearchEngine ose, IEnumerable <NetworkCredential> netCreds, OpenSearchableFactorySettings settings)
{
return(modelExtension.CreateOpenSearchable(baseUrls, queryFormatArg, ose, netCreds, settings));
}
public object Get(WpsJobProductDescriptionRequestTep request)
{
var context = TepWebContext.GetWebContext(PagePrivileges.EverybodyView);
HttpResult result = null;
try {
context.Open();
context.LogInfo(this, string.Format("/job/wps/{0}/products/description GET", request.JobId));
WpsJob wpsjob = WpsJob.FromIdentifier(context, request.JobId);
OpenSearchEngine ose = MasterCatalogue.OpenSearchEngine;
HttpRequest httpRequest = HttpContext.Current.Request;
OpenSearchDescription osd;
if (CatalogueFactory.IsCatalogUrl(new Uri(wpsjob.StatusLocation)))
{
var settings = MasterCatalogue.OpenSearchFactorySettings;
OpenSearchableFactorySettings specsettings = (OpenSearchableFactorySettings)settings.Clone();
//get credentials from current user
if (context.UserId != 0)
{
var user = UserTep.FromId(context, context.UserId);
var apikey = user.GetSessionApiKey();
var t2userid = user.TerradueCloudUsername;
if (!string.IsNullOrEmpty(apikey))
{
specsettings.Credentials = new System.Net.NetworkCredential(t2userid, apikey);
}
}
GenericOpenSearchable urlToShare = new GenericOpenSearchable(new OpenSearchUrl(wpsjob.StatusLocation), specsettings);
osd = urlToShare.GetOpenSearchDescription();
var oldUri = new UriBuilder(osd.DefaultUrl.Template);
var newUri = new UriBuilder(context.BaseUrl + "/job/wps/" + wpsjob.Identifier + "/products/search");
newUri.Query = oldUri.Query.TrimStart("?".ToCharArray());
osd.DefaultUrl.Template = HttpUtility.UrlDecode(newUri.Uri.AbsoluteUri);
foreach (var url in osd.Url)
{
oldUri = new UriBuilder(url.Template);
newUri = new UriBuilder(context.BaseUrl + "/job/wps/" + wpsjob.Identifier + "/products/search");
newUri.Query = oldUri.Query.TrimStart("?".ToCharArray());
url.Template = HttpUtility.UrlDecode(newUri.Uri.AbsoluteUri);
}
}
else
{
WpsJobProductOpenSearchable wpsjobProductOs = new WpsJobProductOpenSearchable(wpsjob, context);
osd = wpsjobProductOs.GetProxyOpenSearchDescription();
}
result = new HttpResult(osd, "application/opensearchdescription+xml");
context.Close();
} catch (Exception e) {
context.LogError(this, e.Message, e);
context.Close();
throw e;
}
return(result);
}
private bool ProcessAlternative(List <Uri> uri, List <NetworkCredential> credential, ref bool isAtomFeedPartial, ref bool canceled)
{
// Find OpenSearch Entity
IOpenSearchable entity = null;
int retry = retryAttempts;
int index = 1;
while (retry >= 0)
{
// Perform the query
try {
OpenSearchableFactorySettings settings = new OpenSearchableFactorySettings(ose);
settings.MaxRetries = retryAttempts;
entity = dataModel.CreateOpenSearchable(uri, queryFormatArg, ose, credential, settings);
index = entity.GetOpenSearchDescription().DefaultUrl.IndexOffset;
log.Debug("IndexOffset : " + index);
break;
} catch (Exception e) {
log.Warn(e.Message);
if (retry == 0)
{
throw;
}
retry--;
searchCache.ClearCache(".*", DateTime.Now);
}
}
NameValueCollection parameters = PrepareQueryParameters(entity);
string startIndex = parameters.Get("startIndex");
if (startIndex != null)
{
index = int.Parse(startIndex);
}
NameValueCollection parametersNvc;
IOpenSearchResultCollection osr = null;
long totalCount = 0;
log.DebugFormat("{0} entries requested", totalResults);
if (outputStarted)
{
return(false);
}
while (totalResults > 0)
{
bool closeOutputStream = true;
Stream outputStream = null;
log.DebugFormat("startIndex: {0}", index);
parametersNvc = ResolveParameters(parameters, entity);
// Initialize the output stream
if (outputStream == null)
{
outputStream = InitializeOutputStream(index);
}
else
{
closeOutputStream = false;
}
retry = retryAttempts;
while (retry >= 0)
{
if (canceled)
{
return(false);
}
// Perform the query
log.Debug("Launching query...");
try {
osr = QueryOpenSearch(ose, entity, parametersNvc);
isAtomFeedPartial = false;
break;
} catch (AggregateException ae) {
if (retry == 0)
{
throw ae;
}
foreach (Exception e in ae.InnerExceptions)
{
log.Warn("Exception " + e.Message);
}
retry--;
searchCache.ClearCache(".*", DateTime.Now);
} catch (KeyNotFoundException e) {
log.Error("Query not found : " + e.Message);
throw e;
} catch (PartialAtomException e) {
if (retry == 0)
{
osr = e.PartialOpenSearchResultCollection;
isAtomFeedPartial = true;
}
retry--;
searchCache.ClearCache(".*", DateTime.Now);
} catch (ThreadAbortException) {
} catch (Exception e) {
if (retry == 0)
{
throw;
}
log.Warn("Exception " + e.Message);
retry--;
searchCache.ClearCache(".*", DateTime.Now);
}
}
if (canceled)
{
return(false);
}
int count = CountResults(osr);
if (totalCount == 0 && count == 0)
{
LogInfo("No entries found");
DeleteFileStream(outputStream);
return(false);
}
if (canceled)
{
return(false);
}
if (osr.Count > 0)
{
// Transform the result
OutputResult(osr, outputStream);
}
else
{
closeOutputStream = false;
DeleteFileStream(outputStream);
}
outputStarted = true;
log.Debug(count + " entries found");
if (count == 0)
{
break;
}
int expectedCount = count;
if (!string.IsNullOrEmpty(parameters["count"]) && int.TryParse(parameters["count"], out expectedCount) && count < expectedCount)
{
break;
}
totalResults -= count;
totalCount += count;
log.Debug(count + " entries found on " + totalResults + " requested");
int paramCount;
if (Int32.TryParse(parameters.Get("count"), out paramCount) && totalResults < paramCount)
{
parameters.Set("count", "" + totalResults);
}
index += count;
parameters.Set("startIndex", "" + index);
if (closeOutputStream)
{
outputStream.Close();
}
}
return(totalCount > 0); // success
}
