public bool IsValid <TDocument>(ISearchParameter searchParameter, out string errorMessage)
where TDocument : Document
{
errorMessage = string.Empty;
var facetRangeParameter = (IFacetRangeParameter <TDocument>)searchParameter;
var propertyType = facetRangeParameter.ExpressionBuilder.GetPropertyType(facetRangeParameter.FieldExpression);
var allowedTypes = new[]
{
typeof(DateTime),
typeof(DateTime?),
typeof(decimal),
typeof(decimal?),
typeof(double),
typeof(double?),
typeof(float),
typeof(float?),
typeof(int),
typeof(int?),
typeof(long),
typeof(long?),
typeof(short),
typeof(short?),
};
if (!allowedTypes.Contains(propertyType))
{
errorMessage = Resource.FieldMustBeNumericOrDateTimeToBeUsedInFacetRangeException;
return(false);
}
return(true);
}
internal SearchFor(SearchFor currentSearch, ISearchParameter newParameter)
{
_parameters = new List <ISearchParameter>(currentSearch._parameters)
{
newParameter
};
}
public bool IsValid <TDocument>(ISearchParameter searchParameter, out string errorMessage)
where TDocument : Document
{
var anyParameter = searchParameter as IAnyParameter;
if (anyParameter == null)
{
errorMessage = null;
return(true);
}
var specificParameters = new List <string> {
"facet.field",
"facet.limit",
"facet.query",
"facet.range",
"fl",
"fq",
"mm",
"q",
"qf",
"rows",
"sort",
"start"
};
errorMessage = string.Format(Resource.UseSpecificParameterRatherThanAnyException, anyParameter.Name);
return(!specificParameters.Contains(anyParameter.Name.ToLowerInvariant()));
}
public static ISearchQuery CreateSearchQuery(IQueryCollection queryCollection, ISearchFunction searchFunction)
{
List <SearchParameterSet> sets = new List <SearchParameterSet>();
List <ISearchParameter> parameters = new List <ISearchParameter>();
foreach (var kvp in queryCollection)
{
foreach (var value in kvp.Value)
{
if (string.IsNullOrEmpty(value))
{
continue;
}
ISearchParameter parameter = CreateParameter(kvp.Key, kvp.Value, searchFunction.SearchCriterionSet);
if (parameter != null)
{
parameters.Add(parameter);
}
}
}
SearchParameterSet set = new SearchParameterSet(parameters);
sets.Add(set);
return(new SearchQuery(sets.LastOrDefault()));
}
public BinSearchSpectrumEThcD(ISearchParameter parameter)
{
calculator = UtilMass.Instance;
option = UtilMassOption.Instance;
this.parameter = parameter;
alpha = 1.0;
beta = 0.0;
}
public BinSearchSpectrumEThcD(double tol = 20)
{
calculator = UtilMass.Instance;
option = UtilMassOption.Instance;
parameter = new BinSearchSpectrumEThcDParameter(tol);
alpha = 1.0;
beta = 0.0;
}
public static Expression <Func <T, bool> > GetPredicate <T>(ISearchParameter parameters, ISitecoreContext context) where T : IFacetableContent
{
var predicate = PredicateBuilder.True <T>();
predicate = parameters.FilterOnTemplates.Aggregate(predicate, (current, temp) => current.Or(p => p.TemplateId == temp));
if (parameters.FilterOnFields == null || !parameters.FilterOnFields.Any())
{
return(predicate);
}
IEnumerable <Guid> facetOns = parameters.FilterOnFields;
IEnumerable <Models.Glass.Reboot.Facet> facets =
facetOns.Select(i => context.GetItem <Models.Glass.Reboot.Facet>(i)).Reverse();
foreach (var filter in facets)
{
string s = HttpContext.Current.Request.QueryString.Get(filter.Name);
switch (filter.FacetName)
{
case "Genres":
if (!string.IsNullOrEmpty(s) && ShortID.IsShortID(s))
{
//w = w.Where(a => a.Genres.Contains(Guid.Parse(s)));
predicate = predicate.And(o => o.Genres.Contains(Guid.Parse(s)));
}
break;
case "Production Company":
if (!string.IsNullOrEmpty(s) && ShortID.IsShortID(s))
{
//w = w.Where(a => a.ProductionCompanies.Contains(Guid.Parse(s)));
predicate = predicate.And(a => a.ProductionCompanies.Contains(Guid.Parse(s)));
}
break;
case "Status":
if (!string.IsNullOrEmpty(s))
{
//w = w.Where(a => a.Status.Equals(s));
predicate = predicate.And(a => a.Status.Equals(s));
}
break;
case "Spoken Language":
if (!string.IsNullOrEmpty(s))
{
//w = w.Where(a => a.Status.Equals(s));
predicate = predicate.And(a => a.SpokenLanguages.Contains(Guid.Parse(s)));
}
break;
}
}
return(predicate);
}
public void ParameterCreationTest()
{
TypedCriterion <double> criterion = new TypedCriterion <double>("{{test}parameter");
criterion.ValuePattern = new System.Text.RegularExpressions.Regex(@"^\d*.\d{2}$");
criterion.ValueRange = new Model.Implementation.Range <double>(10.0, 20.0);
ISearchParameter parameter = criterion.CreateParameter("0");
Assert.IsAssignableFrom <WrongSearchParameter>(parameter);
Assert.Contains("regular expression", ((WrongSearchParameter)parameter).ErrorMessage);
}
public bool IsValid <TDocument>(ISearchParameter searchParameter, out string errorMessage)
where TDocument : Document
{
var searchParameterFieldExpressions = searchParameter as ISearchItemFieldExpressions <TDocument>;
var searchParameterFieldExpression = searchParameter as ISearchItemFieldExpression <TDocument>;
var fieldExpressions =
searchParameterFieldExpressions?.FieldExpressions ??
new[] { searchParameterFieldExpression?.FieldExpression };
var expressionBuilder =
searchParameterFieldExpressions?.ExpressionBuilder ??
searchParameterFieldExpression?.ExpressionBuilder;
if (fieldExpressions.Any(fieldExpression => !expressionBuilder?.GetIsIndexed(fieldExpression) ?? false))
{
errorMessage = Resource.FieldMustBeIndexedTrueToBeUsedInThisFunctionException;
return(false);
}
errorMessage = string.Empty;
return(true);
}
/// <summary>
/// Method to retriev a special Number of Dummy Results
/// </summary>
/// <param name="numberOfResults">number of results to retriev</param>
/// <returns>Results in Reposiotry</returns>
public IDummySearchResultModel GetDummyResults(ISearchParameter searchParamter, int numberOfResults = 20)
{
int totalNumberOfResults;
if (numberOfResults <= 0)
{
return(this.EmptySearchResultModel);
}
if (numberOfResults > this.NumberOfEntriesInRepository)
{
numberOfResults = this.NumberOfEntriesInRepository;
}
totalNumberOfResults = numberOfResults;
IList <IDummyContentModel> results = new List <IDummyContentModel>();
for (int i = 0; i < numberOfResults; i++)
{
results.Add(new DummyContentModel()
{
Title = $"Title_{i}",
Text = $"Text_{i}",
Image = string.Empty,
Link = "http://www.google.de",
});
}
results = results.Skip(ElementsPerPage * (searchParamter.Page - 1)).Take(ElementsPerPage).ToList();
return(new DummySearchResultModel()
{
SearchResults = results,
TotalNumberOfResults = totalNumberOfResults,
Paging = CreatePagingModel(searchParamter.Page, totalNumberOfResults, ElementsPerPage)
});
}
public DPSearchSpectrumCID(double tol = 20, double min = 400, double size = 0.01, int distance = 3)
{
parameter = new DPSpectrumCIDParameter(tol, min, size, distance);
dp = new DynamicProgramming();
}
public DPSearchSpectrumCID(DPSpectrumCIDParameter parameter)
{
this.parameter = parameter;
dp = new DynamicProgramming();
}
public void SetParameter(ISearchParameter parameter)
{
this.parameter = parameter;
}
public virtual void Add(ISearchParameter parameter)
{
set.Add(parameter);
}
private SearchFor(ISearchParameter parameter)
{
_parameters = new List <ISearchParameter> {
parameter
};
}
public virtual void Insert(int pos, ISearchParameter parameter)
{
set.Insert(pos, parameter);
}
/// <summary>
/// Method to retriev all availbalbe Dummy Results
/// </summary>
/// <returns>All Results in Repository</returns>
public IDummySearchResultModel GetAllDummyResults(ISearchParameter searchParameter)
{
return(GetDummyResults(searchParameter, this.NumberOfEntriesInRepository));
}
public bool Equals(ISearchParameter other)
{
throw new NotImplementedException();
}
/// <summary>
/// Dummy Query
/// </summary>
/// <param name="sp">search paramter</param>
/// <returns>dummy results</returns>
protected IDummySearchResultModel ExecuteDummyQuery(ISearchParameter sp)
{
return(DummyRepo.GetDummyResults(sp, Labels.NumberOfWantedResults));
}
public BinSearchAnnotatedSpectrumEThcD(
List <IAccumulatedGlycanStructureProxy> glycans, double tol = 20)
{
parameter = new BinSearchSpectrumEThcDParameter(tol);
Constructor(glycans);
}
public BinSearchAnnotatedSpectrumEThcD(
List <IAccumulatedGlycanStructureProxy> glycans, ISearchParameter parameter)
{
this.parameter = parameter;
Constructor(glycans);
}
