internal static IEnumerable <KeyValuePair <string, Expression <Func <FindDocument, Filter> > > > GetFacets(this ITypeSearch <FindDocument> search, SearchFilter filter, string locale)
{
ISearchConfiguration config = search.Client.GetConfiguration();
IFieldConfiguration field;
int index;
if (FindProviderExtensions.IsSimpleFacet(filter) && config.TryGetField(filter.field, locale, out field))
{
SimpleValue[] simpleValueArray = filter.Values.SimpleValue;
for (index = 0; index < simpleValueArray.Length; ++index)
{
SimpleValue simpleValue = simpleValueArray[index];
yield return(new KeyValuePair <string, Expression <Func <FindDocument, Filter> > >(FindProviderExtensions.EncodeFacetName(field.Name, simpleValue.key), UntypedFilterBuilder.GetMatchFilter(field, simpleValue.value)));
}
simpleValueArray = (SimpleValue[])null;
}
if (FindProviderExtensions.IsRangeFacet(filter) && config.TryGetField(filter.field, locale, out field))
{
RangeValue[] rangeValueArray = filter.Values.RangeValue;
for (index = 0; index < rangeValueArray.Length; ++index)
{
RangeValue rangeValue = rangeValueArray[index];
yield return(new KeyValuePair <string, Expression <Func <FindDocument, Filter> > >(FindProviderExtensions.EncodeFacetName(field.Name, rangeValue.key), UntypedFilterBuilder.GetRangeFilter(field, rangeValue.lowerbound, rangeValue.upperbound, rangeValue.lowerboundincluded, rangeValue.upperboundincluded)));
}
rangeValueArray = (RangeValue[])null;
}
}
static async Task Main(string[] args)
{
try
{
var builder = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("appsettings.json");
var localConfiguration = builder.Build();
Configuration = ConfigurationService.GetConfig(
localConfiguration["EnvironmentName"],
localConfiguration["ConfigurationStorageConnectionString"],
localConfiguration["Version"],
localConfiguration["ServiceName"])
.Result;
Console.WriteLine($"Retrieved configuration. ");
Console.WriteLine($" - Search Service Name: '{Configuration.AzureSearchConfiguration.Name}'");
Console.WriteLine($" - Sql Connection String: '{Configuration.SqlConnectionString}'");
var serviceCollection = new ServiceCollection();
ConfigureServices(serviceCollection);
var serviceProvider = serviceCollection.BuildServiceProvider();
await serviceProvider.GetService <App>().Run();
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
public Startup(IConfiguration configuration)
{
Configuration = ConfigurationService.GetConfig(configuration["EnvironmentName"],
configuration["ConfigurationStorageConnectionString"],
configuration["Version"],
configuration["ServiceName"]).Result;
}
private IClient CreateClient(ISearchConfiguration config)
{
ProviderClient providerClient = new ProviderClient(config);
providerClient.Conventions.ContractResolver.ContractInterceptors.Add((IInterceptContract) new IncludeTypeNameInDictionaryKeyFieldNameConvention());
return((IClient)providerClient);
}
/// <summary>
/// Method is used for getting direct facets without getting search results
/// </summary>
/// <param name="requestModel">Request Models</param>
/// <param name="searchConfiguration">Search Configuration (Required)</param>
/// <returns>List of facets</returns>
public IEnumerable <FacetModel> GetFacets(TRequest requestModel, ISearchConfiguration searchConfiguration)
{
try
{
if (searchConfiguration != null)
{
SetIndexConfiguration(searchConfiguration);
}
Assert.IsNotNull(Index, "Index");
Assert.IsNotNull(SearchConfiguration, "SearchConfiguration is null");
if (!EnsureIndexExistence(Index))
{
return(new List <FacetModel>());
}
using (IProviderSearchContext searchContext = Index.CreateSearchContext())
{
var items = searchContext.GetQueryable <TIndexModel>(
new CultureExecutionContext(Context.Language.CultureInfo));
return(GetFacets(items, requestModel));
}
}
catch (Exception ex)
{
Logging.Log.Error("Error occurred during getting facets: Error message:" + ex.ToString(), ex);
}
return(new List <FacetModel>());
}
/// <summary>
/// Initializes a new instance of the <see cref="T:KotoriCore.Configuration.KotoriConfiguration"/> class.
/// </summary>
/// <param name="instance">Instance.</param>
/// <param name="version">Version.</param>
/// <param name="masterKeys">Master keys.</param>
/// <param name="database">Database.</param>
/// <param name="search">Search service.</param>
public KotoriConfiguration(string instance, string version, IEnumerable <MasterKey> masterKeys, IDatabaseConfiguration database, ISearchConfiguration search)
{
Instance = instance;
Version = version;
MasterKeys = masterKeys;
Database = database;
Search = search;
}
public SearchResultsImplementation(ISearchConfiguration config, SearchResults <FindDocument> results, ISearchCriteria criteria)
: base((ISearchDocuments) new SearchDocumentsImplementation(config, criteria.Locale, results), criteria)
{
this._totalCount = results.TotalMatching;
this.Suggestions = new string[0];
this._keyFieldValues = results.Hits.Select <SearchHit <FindDocument>, int>((Func <SearchHit <FindDocument>, int>)(h => h.Document.CatalogEntryId)).ToArray <int>();
this.FacetGroups = (ISearchFacetGroup[])this.BuildFacetResults(results, criteria).ToArray <FacetGroup>();
}
public MergeOrUploadHandler(VideoCollectionDataContext dataContext, ISearchConfiguration searchConfiguration)
{
_dataContext = dataContext;
_searchIndexClient = new SearchIndexClient(
searchConfiguration.SearchServiceName,
searchConfiguration.IndexName,
new SearchCredentials(searchConfiguration.ApiKey));
}
public GetSuggestResultsHandler(
ISearchConfiguration searchConfiguration
)
{
_documentOperations = new SearchIndexClient(
searchConfiguration.SearchServiceName,
searchConfiguration.IndexName,
new SearchCredentials(searchConfiguration.ApiKey)).Documents;
}
public SearchTransport(ISearchConfiguration config)
{
_config = config;
_httpClient = new HttpClient();
_httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue(
"Basic",
Convert.ToBase64String(
Encoding.ASCII.GetBytes(
string.Format("{0}:{1}", config.Username, config.Password))));
}
public SearchIndexingQueueService(ISearchConfiguration searchConfiguration)
{
_jsonSettings = new JsonSerializerSettings()
{
NullValueHandling = NullValueHandling.Ignore,
DefaultValueHandling = DefaultValueHandling.Ignore
};
_searchConfiguration = searchConfiguration;
_sqsExtendedClient = CreateExtendedClient();
}
internal SqlItemSearchRepository(
ISqlConnectionWrapper connectionWrapper,
ISearchConfiguration configuration,
IArtifactPermissionsRepository artifactPermissionsRepository,
IArtifactRepository artifactRepository)
{
_connectionWrapper = connectionWrapper;
_artifactPermissionsRepository = artifactPermissionsRepository;
_searchConfigurationProvider = new SearchConfigurationProvider(configuration);
_artifactRepository = artifactRepository;
}
/// <summary>
/// Initializes a new instance of the <see cref="T:KotoriCore.Configurations.KotoriConfiguration"/> class.
/// </summary>
/// <param name="configuration">Configuration.</param>
public KotoriConfiguration(IConfiguration configuration)
{
var configurationSection = configuration.GetSection("Kotori").GetSection("Configuration");
Instance = configurationSection.GetValue <string>("Instance");
Version = configurationSection.GetValue <string>("Version");
MasterKeys = configurationSection.GetSection("MasterKeys").GetChildren().Select(x => x.Get <MasterKey>());
// database
Database = configuration.GetSection("Kotori:DocumentDb").Get <DocumentDbConfiguration>();
// search service
Search = configuration.GetSection("Kotori:AzureSearch").Get <AzureSearchConfiguration>();
}
/// <summary>
/// Searches for the specified query in all default search fields, and in the specified locale.
/// </summary>
/// <param name="search">The search to modify.</param>
/// <param name="query">The query text to search for.</param>
/// <param name="locale">The locale to search in.</param>
/// <returns>The search, modified to include the requested query.</returns>
public static ITypeSearch <FindDocument> ForDefaultFields(this ITypeSearch <FindDocument> search, string query, string locale)
{
if (!string.IsNullOrEmpty(query))
{
ISearchConfiguration configuration = search.Client.GetConfiguration();
IQueriedSearch <FindDocument, QueryStringQuery> search1 = search.For <FindDocument>(query);
Enumerable.Empty <IFieldConfiguration>();
foreach (IFieldConfiguration fieldConfiguration1 in !string.IsNullOrWhiteSpace(locale) ? configuration.GetDefaultFields(locale) : configuration.GetDefaultFields())
{
if (fieldConfiguration1.Type == typeof(string))
{
IFieldConfiguration <string> fieldConfiguration2 = (IFieldConfiguration <string>)fieldConfiguration1;
search1 = search1.InField <FindDocument, QueryStringQuery>(fieldConfiguration2.TypedGetValueExpression, new double?());
}
else if (fieldConfiguration1.Type == typeof(IEnumerable <string>))
{
IFieldConfiguration <IEnumerable <string> > fieldConfiguration2 = (IFieldConfiguration <IEnumerable <string> >)fieldConfiguration1;
search1 = search1.InField <FindDocument, QueryStringQuery>(fieldConfiguration2.TypedGetValueExpression, new double?());
}
else if (fieldConfiguration1.Type == typeof(int?))
{
IFieldConfiguration <int?> fieldConfiguration2 = (IFieldConfiguration <int?>)fieldConfiguration1;
search1 = search1.InField <FindDocument, QueryStringQuery>(fieldConfiguration2.TypedGetValueExpression, new double?());
}
else if (fieldConfiguration1.Type == typeof(int))
{
IFieldConfiguration <int> fieldConfiguration2 = (IFieldConfiguration <int>)fieldConfiguration1;
search1 = search1.InField <FindDocument, QueryStringQuery>(fieldConfiguration2.TypedGetValueExpression, new double?());
}
else if (fieldConfiguration1.Type == typeof(double?) || fieldConfiguration1.Type == typeof(float?))
{
IFieldConfiguration <double?> fieldConfiguration2 = (IFieldConfiguration <double?>)fieldConfiguration1;
search1 = search1.InField <FindDocument, QueryStringQuery>(fieldConfiguration2.TypedGetValueExpression, new double?());
}
else
{
if (!(fieldConfiguration1.Type == typeof(double)) && !(fieldConfiguration1.Type == typeof(float)))
{
throw new Exception(string.Format((IFormatProvider)CultureInfo.InvariantCulture, "Field of type {0} is not valid for the default search.", (object)fieldConfiguration1.Type.Name));
}
IFieldConfiguration <double> fieldConfiguration2 = (IFieldConfiguration <double>)fieldConfiguration1;
search1 = search1.InField <FindDocument, QueryStringQuery>(fieldConfiguration2.TypedGetValueExpression, new double?());
}
}
search = (ITypeSearch <FindDocument>)search1;
}
return(search);
}
/// <summary>
/// Creates an instance of type <see cref="PropertyInfo.PropertyType"/> specified in <see cref="ISearchConfiguration.RequestProperty"/>.
/// </summary>
/// <param name="configuration"></param>
/// <returns></returns>
protected virtual ISearch ActivateSearchProperty(ISearchConfiguration configuration)
{
if (configuration.Constructor != null)
{
return(configuration.Constructor());
}
if (configuration.Activator != null)
{
return(configuration.Activator(serviceProvider).Activate(configuration.ItemPropertyPath));
}
var activator = searchActivatorFactory.Create(configuration.RequestProperty.PropertyType);
return(activator.Activate(configuration.ItemPropertyPath));
}
/// <summary>
/// Adds the document to the index. Depending on the provider, the document will be commited only after commit is called.
/// </summary>
/// <param name="applicationName">Name of the application.</param>
/// <param name="scope">The scope.</param>
/// <param name="document">The document.</param>
/// <exception cref="T:System.ArgumentNullException">document</exception>
/// <exception cref="T:System.NotSupportedException">The EPiServer Find search provider requires the use of the FindSearchIndexBuilder. Please update your search configuration.</exception>
public override void Index(string applicationName, string scope, ISearchDocument document)
{
if (document == null)
{
throw new ArgumentNullException(nameof(document));
}
CatalogEntryWrapper catalogEntryWrapper = document as CatalogEntryWrapper;
if (catalogEntryWrapper == null)
{
throw new NotSupportedException("The EPiServer Find search provider requires the use of the FindSearchIndexBuilder. Please update your search configuration.");
}
ISearchConfiguration providerConfiguration = (this.Client as ProviderClient).ProviderConfiguration;
FindDocument document1 = new FindDocumentBuilder(catalogEntryWrapper.EntryRow, providerConfiguration, catalogEntryWrapper.Languages).Document;
this.AddOperation(document1.CatalogEntryId, document1);
}
public FindDocumentBuilder(CatalogEntryDto.CatalogEntryRow entryRow, ISearchConfiguration configuration, IEnumerable <string> languages)
{
this.Document = new FindDocument();
this.Document.CatalogEntryId = entryRow.CatalogEntryId;
this.Document.CatalogEntryCode = entryRow.Code.ToLowerInvariant();
this.Document.CatalogEntryType = entryRow.ClassTypeId.ToLowerInvariant();
this.Document.MetaClassName = MetaClass.Load(CatalogContext.MetaDataContext, entryRow.MetaClassId).FriendlyName;
this.Document.Name = entryRow.Name.ToLowerInvariant();
this.Document.StartDate = entryRow.StartDate;
this.Document.EndDate = entryRow.EndDate;
this.Document.Languages = languages.Where <string>((Func <string, bool>)(l => entryRow.IsEntryPublished(l))).ToList <string>();
this.Document.IsActive = entryRow.IsActive;
this.BuildPreorderFields(this.Document, entryRow.Code);
this.BuildCatalogStructure(this.Document, entryRow);
this.BuildPrices(this.Document, entryRow, configuration);
this.BuildMetaFields(this.Document, entryRow, configuration);
}
/// <summary>
/// Adds a single active filter from an ISearchCriteria object to an existing search.
/// </summary>
public static ITypeSearch <FindDocument> AddActiveFilter(this ITypeSearch <FindDocument> search, string fieldName, ISearchFilterValue filterValue, string locale, MarketId marketId)
{
ISearchConfiguration configuration = search.Client.GetConfiguration();
SimpleValue simpleValue;
if ((simpleValue = filterValue as SimpleValue) != null)
{
IFieldConfiguration field;
if (configuration.TryGetField(fieldName, locale, out field))
{
Expression <Func <FindDocument, Filter> > matchFilter = UntypedFilterBuilder.GetMatchFilter(field, simpleValue.value);
search = search.Filter <FindDocument>(matchFilter);
}
}
else
{
RangeValue rangeValue;
if ((rangeValue = filterValue as RangeValue) != null)
{
IFieldConfiguration field;
if (configuration.TryGetField(fieldName, locale, out field))
{
search = search.FilterFieldRange(field, rangeValue.lowerbound, rangeValue.upperbound, rangeValue.lowerboundincluded, rangeValue.upperboundincluded);
}
}
else
{
PriceRangeValue priceRangeValue;
if ((priceRangeValue = filterValue as PriceRangeValue) == null)
{
throw new NotSupportedException(string.Format("Unrecognized search filter value type {0}.", (object)filterValue.GetType().Name));
}
IFieldConfiguration <double?> field;
if (configuration.TryGetPriceField(fieldName, new Mediachase.Commerce.Currency(priceRangeValue.currency.ToUpperInvariant()), marketId, out field))
{
search = search.FilterFieldRange((IFieldConfiguration)field, priceRangeValue.lowerbound, priceRangeValue.upperbound, priceRangeValue.lowerboundincluded, priceRangeValue.upperboundincluded);
}
}
}
return(search);
}
private void BuildPrices(FindDocument document, CatalogEntryDto.CatalogEntryRow entryRow, ISearchConfiguration configuration)
{
IPriceService instance = ServiceLocator.Current.GetInstance <IPriceService>();
CatalogKey catalogKey = new CatalogKey(entryRow);
HashSet <Mediachase.Commerce.Currency> source1 = new HashSet <Mediachase.Commerce.Currency>();
HashSet <MarketId> source2 = new HashSet <MarketId>();
IFieldConfiguration <double?> field = null;
foreach (IPriceValue catalogEntryPrice in instance.GetCatalogEntryPrices(catalogKey))
{
HashSet <Mediachase.Commerce.Currency> currencySet = source1;
Money unitPrice = catalogEntryPrice.UnitPrice;
Mediachase.Commerce.Currency currency1 = unitPrice.Currency;
if (currencySet.Add(currency1))
{
ISearchConfiguration searchConfiguration = configuration;
unitPrice = catalogEntryPrice.UnitPrice;
Mediachase.Commerce.Currency currency2 = unitPrice.Currency;
searchConfiguration.AddCurrency(currency2);
}
if (source2.Add(catalogEntryPrice.MarketId))
{
configuration.AddMarket(catalogEntryPrice.MarketId);
}
ISearchConfiguration searchConfiguration1 = configuration;
string name = "saleprice";
unitPrice = catalogEntryPrice.UnitPrice;
Mediachase.Commerce.Currency currencyCode = (Mediachase.Commerce.Currency)unitPrice.Currency.CurrencyCode;
MarketId marketId = (MarketId)catalogEntryPrice.MarketId.Value;
ref IFieldConfiguration <double?> local = ref field;
if (searchConfiguration1.TryGetPriceField(name, currencyCode, marketId, out local))
{
unitPrice = catalogEntryPrice.UnitPrice;
double amount = (double)unitPrice.Amount;
double?nullable = field.GetValue(document);
if (!nullable.HasValue || nullable.Value > amount)
{
field.SetValue(document, new double?(amount));
}
}
}
public SearchDocumentImplementation(ISearchConfiguration config, string locale, SearchHit <FindDocument> hit)
{
this._fields = new List <ISearchField>();
this._fields.Add((ISearchField) new SearchField("_id", (object)hit.Document.CatalogEntryId));
foreach (string language in hit.Document.Languages)
{
config.AddLocale(language);
}
foreach (string currency in hit.Document.Currencies)
{
config.AddCurrency((Mediachase.Commerce.Currency)currency);
}
foreach (string market in hit.Document.Markets)
{
config.AddMarket((MarketId)market);
}
foreach (IFieldConfiguration allField in config.GetAllFields(locale))
{
object obj = allField.GetObjectValue(hit.Document);
IEnumerable <string> source = obj as IEnumerable <string>;
if (source != null)
{
string[] array = source.Where <string>((Func <string, bool>)(v => v != null)).ToArray <string>();
obj = array.Length != 0 ? (object)array : (object)(string[])null;
}
if (obj != null)
{
if (allField.Currency.HasValue)
{
this._fields.Add((ISearchField) new SearchField(string.Format("{0}{1}_{2}", (object)allField.Name, (object)allField.Currency.Value.CurrencyCode, (object)allField.MarketId.Value), obj));
}
else
{
this._fields.Add((ISearchField) new SearchField(allField.Name, obj));
}
}
}
}
public SearchService(ISearchConfiguration searchConfiguration)
{
_searchConfiguration = searchConfiguration;
}
internal ItemSearchController(IItemSearchRepository itemSearchRepo, ISearchConfiguration configuration, IServiceLogRepository serviceLogRepository) : base(serviceLogRepository)
{
_itemSearchRepository = itemSearchRepo;
_searchConfigurationProvider = new SearchConfigurationProvider(configuration);
_criteriaValidator = new CriteriaValidator();
}
public StandardQueryBuilder(IPropertyMapper filterMapper, ISearchConfiguration searchConfiguration, IEnumerable <IDataFormat> dataFormats)
{
_filterMapper = filterMapper;
_searchConfiguration = searchConfiguration;
_dataFormats = dataFormats;
}
public ProductSearchService(ISearchConfiguration searchConfiguration) : base(searchConfiguration)
{
}
/// <summary>For internal use only.</summary>
/// <param name="configuration"></param>
public ProviderClient(ISearchConfiguration configuration)
: base(configuration.ServiceUrl, configuration.DefaultIndex, true, new int?())
{
this.ProviderConfiguration = configuration;
}
public AzureSearchProvider(ISearchConfiguration configuration, ISqlDataRepository sqlDataRepository)
{
_configuration = configuration;
_sqlDataRepository = sqlDataRepository;
}
internal SqlItemSearchRepository(ISqlConnectionWrapper connectionWrapper, ISearchConfiguration configuration) : this(connectionWrapper, configuration, new SqlArtifactPermissionsRepository(connectionWrapper), new SqlArtifactRepository(connectionWrapper))
{
}
internal SqlProjectSearchRepository(ISqlConnectionWrapper connectionWrapper, ISearchConfiguration configuration)
{
_connectionWrapper = connectionWrapper;
_searchConfigurationProvider = new SearchConfigurationProvider(configuration);
}
public SearchTransport(ISearchConfiguration config)
{
_config = config;
}
public SearchConfigurationProvider(ISearchConfiguration configuration)
{
_configuration = configuration;
}
