public static bool MatchesFilter(SubmissionMetaDataModel model, SearchTermModel filter)
{
switch (filter.OperatorProperty)
{
case FilterConstants.CommonFieldOperators.Equal:
{
return(IsEqual(model, filter.FieldValue));
}
case FilterConstants.CommonFieldOperators.NotEqual:
{
return(!IsEqual(model, filter.FieldValue));
}
case FilterConstants.CommonFieldOperators.Empty:
{
return(string.IsNullOrEmpty(model?.Value));
}
case FilterConstants.CommonFieldOperators.NotEmpty:
{
return(!string.IsNullOrEmpty(model?.Value));
}
case FilterConstants.StringFieldOperators.Contains:
{
return(IsContains(model, filter.FieldValue));
}
case FilterConstants.StringFieldOperators.NotContains:
{
return(!IsContains(model, filter.FieldValue));
}
case FilterConstants.StringFieldOperators.EndsWith:
{
return(IsEndsWith(model, filter.FieldValue));
}
case FilterConstants.StringFieldOperators.NotEndsWith:
{
return(!IsEndsWith(model, filter.FieldValue));
}
case FilterConstants.StringFieldOperators.StartsWith:
{
return(IsStartsWith(model, filter.FieldValue));
}
case FilterConstants.StringFieldOperators.NotStartsWith:
{
return(!IsStartsWith(model, filter.FieldValue));
}
default:
{
throw new NotImplementedException($"Filter for FieldName [{filter.FieldName}] has invalid OperatorProperty [{filter.OperatorProperty}]");
}
}
}
public static string GetFieldType(SearchTermModel filter)
{
switch (filter.FieldType)
{
case FilterConstants.FilterFieldTypes.BooleanType:
{
return(nameof(Boolean));
}
case FilterConstants.FilterFieldTypes.DateType:
{
return(nameof(DateTime));
}
case FilterConstants.FilterFieldTypes.NumericalType:
{
return(nameof(Double));
}
case FilterConstants.FilterFieldTypes.StringType:
{
return(nameof(String));
}
default:
{
throw new NotImplementedException($"Filter for FieldName [{filter.FieldName}] has invalid FieldType [{filter.FieldType}]");
}
}
}
public static bool MatchesFilter(SubmissionMetaDataModel model, SearchTermModel filter)
{
var modelValue = GetNumericalValue(model?.Value);
var filterValue = GetNumericalValue(filter?.FieldValue);
switch (filter.OperatorProperty)
{
case FilterConstants.CommonFieldOperators.Equal:
return(modelValue == filterValue);
case FilterConstants.CommonFieldOperators.NotEqual:
return(modelValue != filterValue);
case FilterConstants.CommonFieldOperators.Empty:
return(modelValue == null);
case FilterConstants.CommonFieldOperators.NotEmpty:
return(modelValue != null);
case FilterConstants.NumericalFieldOperators.GreaterThan:
return(modelValue > filterValue);
case FilterConstants.NumericalFieldOperators.GreaterThanOrEqualTo:
return(modelValue >= filterValue);
case FilterConstants.NumericalFieldOperators.LessThan:
return(modelValue < filterValue);
case FilterConstants.NumericalFieldOperators.LessThanOrEqualTo:
return(modelValue <= filterValue);
default: throw new NotImplementedException($"Filter for FieldName [{filter.FieldName}] has invalid OperatorProperty [{filter.OperatorProperty}]");
}
}
private bool MatchesFilterTest(string filterType, string fieldValue)
{
var fieldName = "Test";
var filter = new SearchTermModel()
{
FieldName = fieldName,
FieldType = filterType,
FieldValue = fieldValue,
OperatorProperty = FilterConstants.CommonFieldOperators.Equal
};
var submitContext = GetSubmitContext();
submitContext.CoreMetaData.Add(
new SubmissionMetaDataModel()
{
Name = fieldName,
Type = FilterHelpers.GetFieldType(filter),
Value = fieldValue
}
);
return(FilterHelpers.MatchesFilter(submitContext, filter).Result);
}
public void GetField_CanGetSourceField()
{
var fieldName = Guid.NewGuid().ToString();
var submitContext = GetSubmitContext();
submitContext.SourceMetaData.Add(
new SubmissionMetaDataModel()
{
Name = fieldName,
Type = nameof(String),
Value = "Test"
}
);
var filter = new SearchTermModel()
{
FieldName = GetSourceFieldName(Guid.NewGuid(), fieldName, nameof(String)),
FieldType = nameof(String),
FieldValue = "Test",
OperatorProperty = FilterConstants.CommonFieldOperators.Equal
};
var field = FilterHelpers.GetField(submitContext, filter, nameof(String));
Assert.Equal(fieldName, field.Name);
}
public static bool MatchesFilter(SubmissionMetaDataModel model, SearchTermModel filter)
{
var fieldValue = GetDateTimeValue(model?.Value);
var filterValue = GetDateTimeValue(filter.FieldValue);
switch (filter.OperatorProperty)
{
case FilterConstants.CommonFieldOperators.Equal:
{
if (fieldValue.HasValue && filterValue.HasValue)
{
return(fieldValue.Value >= filterValue.Value && fieldValue < filterValue.Value.AddHours(24));
}
else
{
return(fieldValue == filterValue);
}
}
case FilterConstants.CommonFieldOperators.NotEqual:
{
if (fieldValue.HasValue && filterValue.HasValue)
{
return(fieldValue.Value < filterValue.Value || fieldValue >= filterValue.Value.AddHours(24));
}
else
{
return(fieldValue != filterValue);
}
}
case FilterConstants.CommonFieldOperators.Empty:
{
return(fieldValue == null);
}
case FilterConstants.CommonFieldOperators.NotEmpty:
{
return(fieldValue != null);
}
case FilterConstants.DateFieldOperators.Before:
{
return(fieldValue < filterValue);
}
case FilterConstants.DateFieldOperators.After:
{
return(fieldValue > filterValue);
}
default:
{
throw new NotImplementedException($"Filter for FieldName [{filter.FieldName}] has invalid OperatorProperty [{filter.OperatorProperty}]");
}
}
}
public async Task <IActionResult> SearchAsync(SearchTermModel term)
{
var result = await searchService.SearchAsync(term.CustomerId);
if (result.IsSuccess)
{
return(Ok(result.SearchResults));
}
return(NotFound());
}
public virtual async Task <ActionResult> Index(SearchTermModel model)
{
if (model.Query.IsNullOrWhiteSpace())
{
return(View());
}
if (Request.QueryString.AllKeys.Length == 1 && !string.IsNullOrWhiteSpace(Request.QueryString["Query"]))
{
model.SearchPlace = SearchPlace.Title;
}
var result = await _searchEngine.SearchAsync(model.Query, model.FilterByCategory, model.LanguageId ?? 0,
model.PostType, model.SearchPlace, model.OrderBy);
if (result.HasError)
{
var errorCode = ErrorLog.GetDefault(System.Web.HttpContext.Current).Log(new Error(result.Error, System.Web.HttpContext.Current));
ViewBag.ErrorCode = errorCode;
return(View("Error"));
}
model.Query = model.Query.Trim();
model.PageSize = model.PageSize ?? int.MaxValue;
model.Page = model.Page ?? 1;
var currentUser = UserManager.FindById(User.Identity.GetUserId());
var posts = _postService.GetItemsById(result.Documents.Select(p => p.DocumentId).ToList(), model.Page.Value,
model.PageSize.Value);
var viewModel = new SearchResultModel
{
TimeElapsed = result.ElapsedMilliseconds,
SearchTerm = model,
NumberOfItemsFound = posts.Count,
SearchResult = _postModelFactory.PreparePostCardViewModel(posts, currentUser, Url),
SuggestSimilar = result.SuggestSimilar,
CardViewStyles = ViewStyles.Normal
};
foreach (var document in result.Documents)
{
var post = viewModel.SearchResult.FirstOrDefault(p => p.Id == document.DocumentId);
if (post != null)
{
post.DescriptionTruncated = document.DocumentBody;
post.Title = document.DocumentTitle;
}
}
return(View(viewModel));
}
public AddressDetails GetContactAddress(SearchTermModel searchTerm)
{
try
{
var addressContact = _addressBookEngine.RequestToRetrieveContact(searchTerm);
return(addressContact);
}
catch (Exception ex)
{
throw new Exception("Failed to retrieve contact", ex);
}
}
public IActionResult SearchTermEditor(int searchTermId)
{
var searchTerm = searchTermId > 0 ? _searchTermService.Get(searchTermId) : new SearchTerm();
var model = new SearchTermModel()
{
Id = searchTermId,
Score = searchTerm.Score,
Term = searchTerm.Term,
TermCategory = searchTerm.TermCategory
};
return(R.Success.With("searchTerm", model).Result);
}
public void SaveSearchTest_WhenUpdate()
{
var target = GetTarget();
var targetSearch = new SearchModel();
targetSearch.SearchName = Guid.NewGuid().ToString();
targetSearch.CreatedOnUtc = System.DateTime.UtcNow;
var t1 = new SearchTermModel();
t1.Term = "Static";
t1.Score = 1;
var t2 = new SearchTermModel();
t2.Term = "Dynamic";
t2.Score = 2;
targetSearch.SearchTerms = new List <ISearchTerm>();
targetSearch.SearchTerms.Add(t1);
targetSearch.SearchTerms.Add(t2);
target.SaveSearch(targetSearch);
//check existing
using (var ctx = new SearcherEntities())
{
var existing = ctx.Searches.Single(x => x.SearchName == targetSearch.SearchName);
var existingT1 = existing.SearchTerms.Single(x => x.Term == t1.Term);
var existingT2 = existing.SearchTerms.Single(x => x.Term == t2.Term);
Assert.AreEqual(t1.Score, existingT1.Score, "First Term Scores do not match");
Assert.AreEqual(t2.Score, existingT2.Score, "Second Term Scores do not match");
targetSearch.Id = existing.Id;
}
var t3 = new SearchTermModel();
t3.Term = "Brand New";
t3.Score = 3;
targetSearch.SearchTerms.Remove(t1);
t2.Score = 100;
targetSearch.SearchTerms.Add(t3);
target.SaveSearch(targetSearch);
using (var ctx = new SearcherEntities())
{
var existing = ctx.Searches.Single(x => x.Id == targetSearch.Id);
var newTerm = existing.SearchTerms.Single(x => x.Term == t3.Term);
var deleted = existing.SearchTerms.SingleOrDefault(x => x.Term == t1.Term);
Assert.IsNull(deleted, "Deleted Term exists in Database");
var existingTerm = existing.SearchTerms.SingleOrDefault(x => x.Term == t2.Term);
Assert.IsTrue(existingTerm.Score == t2.Score, "Updated Score does not match");
}
}
public void SaveSearchTest_WhenDuplicateTerms()
{
var target = GetTarget();
var targetSearch = new SearchModel();
targetSearch.SearchName = Guid.NewGuid().ToString();
var t1 = new SearchTermModel();
t1.Term = "Duplicate";
t1.Score = 1;
var t2 = new SearchTermModel();
t2.Term = "Duplicate";
t2.Score = 2;
targetSearch.SearchTerms = new List<ISearchTerm> {t1, t2};
target.SaveSearch(targetSearch);
}
public IActionResult SaveSearchTerm(SearchTermModel searchTermModel)
{
var searchTerm = searchTermModel.Id > 0 ? _searchTermService.Get(searchTermModel.Id) : new SearchTerm();
if (searchTerm == null)
{
return(NotFound());
}
_modelMapper.Map(searchTermModel, searchTerm);
_searchTermService.InsertOrUpdate(searchTerm);
return(R.Success.With("id", searchTerm.Id).Result);
}
public void SaveSearchTest_WhenUpdate()
{
var target = GetTarget();
var targetSearch = new SearchModel();
targetSearch.SearchName = Guid.NewGuid().ToString();
targetSearch.CreatedOnUtc = System.DateTime.UtcNow;
var t1 = new SearchTermModel();
t1.Term = "Static";
t1.Score = 1;
var t2 = new SearchTermModel();
t2.Term = "Dynamic";
t2.Score = 2;
targetSearch.SearchTerms = new List<ISearchTerm>();
targetSearch.SearchTerms.Add(t1);
targetSearch.SearchTerms.Add(t2);
target.SaveSearch(targetSearch);
//check existing
using (var ctx = new SearcherEntities())
{
var existing = ctx.Searches.Single(x => x.SearchName == targetSearch.SearchName);
var existingT1 = existing.SearchTerms.Single(x => x.Term == t1.Term);
var existingT2 = existing.SearchTerms.Single(x => x.Term == t2.Term);
Assert.AreEqual(t1.Score, existingT1.Score, "First Term Scores do not match");
Assert.AreEqual(t2.Score, existingT2.Score, "Second Term Scores do not match");
targetSearch.Id = existing.Id;
}
var t3 = new SearchTermModel();
t3.Term = "Brand New";
t3.Score = 3;
targetSearch.SearchTerms.Remove(t1);
t2.Score = 100;
targetSearch.SearchTerms.Add(t3);
target.SaveSearch(targetSearch);
using (var ctx = new SearcherEntities())
{
var existing = ctx.Searches.Single(x => x.Id == targetSearch.Id);
var newTerm = existing.SearchTerms.Single(x => x.Term == t3.Term);
var deleted = existing.SearchTerms.SingleOrDefault(x => x.Term == t1.Term);
Assert.IsNull(deleted, "Deleted Term exists in Database");
var existingTerm = existing.SearchTerms.SingleOrDefault(x => x.Term == t2.Term);
Assert.IsTrue(existingTerm.Score == t2.Score, "Updated Score does not match");
}
}
public static SubmissionMetaDataModel GetField(SubmitContext submitContext, SearchTermModel filter, string expectedFieldType)
{
// Format of a source field name in Records365: S|<ConnectorTypeId>|<DataType>|<FieldName>
if (filter.FieldName.StartsWith(_sourceFieldPrefix))
{
// Avoiding String.Split due to performance concerns. Not using LastIndexOf in case a Field name contains a pipe.
// We want to skip over S|<ConnectorTypeId>|, which has a known length (39 characters), then find the index of the first pipe following that.
// After that pipe, the rest should be the Source property's field name
var lastPipeIndex = filter.FieldName.IndexOf(_separator, _indexAfterSeparator);
var sourceFieldName = filter.FieldName.Substring(lastPipeIndex + 1);
return(submitContext?.SourceMetaData?.FirstOrDefault(x => x.Name == sourceFieldName && x.Type == expectedFieldType));
}
return(submitContext?.CoreMetaData?.FirstOrDefault(x => x.Name == filter.FieldName));
}
private List <SearchTermModel> collectSearchTerms()
{
List <SearchTermModel> searchTerms = new List <SearchTermModel>();
foreach (Control control in this.Controls)
{
if ((control is TextBox | control is ComboBox) & control.Text != "")
{
SearchTermModel searchTerm = new SearchTermModel();
searchTerm.SearchTerm = control.Tag.ToString();
searchTerm.SearchValue = control.Text;
searchTerms.Add(searchTerm);
searchTerm = null;
}
}
return(searchTerms);
}
public AddressDetails GetContact(SearchTermModel searchTerm)
{
try
{
var filter = Builders <AddressDetails> .Filter.Eq(a => a.FirstName, searchTerm.FirstName);
var addressContact = _addressCollection
.Find(filter)
.FirstOrDefault();
return(addressContact);
}
catch (DbException ex)
{
throw;
}
}
public void SaveSearchTest_WhenDuplicateTerms()
{
var target = GetTarget();
var targetSearch = new SearchModel();
targetSearch.SearchName = Guid.NewGuid().ToString();
var t1 = new SearchTermModel();
t1.Term = "Duplicate";
t1.Score = 1;
var t2 = new SearchTermModel();
t2.Term = "Duplicate";
t2.Score = 2;
targetSearch.SearchTerms = new List <ISearchTerm> {
t1, t2
};
target.SaveSearch(targetSearch);
}
public void OperatorPropertyNull_MatchesBoolFilterTest()
{
var expectedValue = new SubmissionMetaDataModel()
{
DisplayName = nameof(String),
Name = nameof(String),
Type = nameof(String),
Value = nameof(String),
};
var filterValue = new SearchTermModel()
{
FieldName = FilterConstants.FilterFieldTypes.StringType,
FieldType = FilterConstants.FilterFieldTypes.BooleanType,
FieldValue = FilterConstants.FilterFieldTypes.StringType,
OperatorProperty = null
};
Assert.Throws <NotImplementedException>(() => BooleanFilter.MatchesFilter(expectedValue, filterValue));
}
public void InvalidDateTimeFilterTests(string submitValue, string filterFieldValue, string operatorType)
{
var expectedValue = new SubmissionMetaDataModel()
{
DisplayName = nameof(String),
Name = nameof(String),
Type = nameof(String),
Value = submitValue
};
var filterValue = new SearchTermModel()
{
FieldName = FilterConstants.FilterFieldTypes.StringType,
FieldType = FilterConstants.FilterFieldTypes.DateType,
FieldValue = filterFieldValue,
OperatorProperty = operatorType
};
Assert.Throws <ValidationException>(() => DateTimeFilter.MatchesFilter(expectedValue, filterValue));
}
public static bool MatchesFilter(SubmissionMetaDataModel model, SearchTermModel filter)
{
switch (filter.OperatorProperty)
{
case FilterConstants.CommonFieldOperators.Equal:
{
return(IsEqual(model, filter.FieldValue));
}
case FilterConstants.CommonFieldOperators.NotEqual:
{
return(!IsEqual(model, filter.FieldValue));
}
default:
{
throw new NotImplementedException($"Filter for FieldName [{filter.FieldName}] has invalid OperatorProperty [{filter.OperatorProperty}]");
}
}
}
private bool MatchesFilterTest(string filterfieldValue, string modelValue, string operatorProperty)
{
var fieldName = "Test";
var filter = new SearchTermModel()
{
FieldName = fieldName,
FieldType = FilterConstants.FilterFieldTypes.StringType,
FieldValue = filterfieldValue,
OperatorProperty = operatorProperty
};
var model = new SubmissionMetaDataModel()
{
Name = fieldName,
Type = FilterHelpers.GetFieldType(filter),
Value = modelValue
};
return(StringFilter.MatchesFilter(model, filter));
}
public void ValidDateTimeFilterTests(string submitValue, string filterFieldValue, string operatorType, bool expectedResult)
{
var expectedValue = new SubmissionMetaDataModel()
{
DisplayName = nameof(String),
Name = nameof(String),
Type = nameof(String),
Value = submitValue
};
var filterValue = new SearchTermModel()
{
FieldName = FilterConstants.FilterFieldTypes.StringType,
FieldType = FilterConstants.FilterFieldTypes.DateType,
FieldValue = filterFieldValue,
OperatorProperty = operatorType
};
var result = DateTimeFilter.MatchesFilter(expectedValue, filterValue);
Assert.Equal(expectedResult, result);
}
public void DoesNotMatchBoolFilterTest(string submitValue, string fieldValue, bool expectedResult)
{
var expectedValue = new SubmissionMetaDataModel()
{
DisplayName = nameof(String),
Name = nameof(String),
Type = nameof(String),
Value = submitValue
};
var filterValue = new SearchTermModel()
{
FieldName = FilterConstants.FilterFieldTypes.StringType,
FieldType = FilterConstants.FilterFieldTypes.BooleanType,
FieldValue = fieldValue,
OperatorProperty = FilterConstants.CommonFieldOperators.NotEqual
};
var result = BooleanFilter.MatchesFilter(expectedValue, filterValue);
Assert.Equal(expectedResult, result);
}
public virtual async Task <ActionResult> Tag(string tag, int?page)
{
if (tag.IsNullOrWhiteSpace())
{
return(View("Index"));
}
var result = await _searchEngine.SearchAsync($"\"{tag}\"", null, 0, null, SearchPlace.Tags,
SearchResultSortType.Score, 1000, true);
if (result.HasError)
{
var errorCode = ErrorLog.GetDefault(System.Web.HttpContext.Current).Log(new Error(result.Error, System.Web.HttpContext.Current));
ViewBag.ErrorCode = errorCode;
return(View("Error"));
}
var searchTerm = new SearchTermModel {
Query = tag.Trim(), Page = page ?? 1, PageSize = 20
};
var currentUser = UserManager.FindById(User.Identity.GetUserId());
var posts = _postService.GetItemsById(result.Documents.Select(p => p.DocumentId).ToList(),
searchTerm.Page.Value, searchTerm.PageSize.Value);
var viewModel = new SearchResultModel
{
TimeElapsed = result.ElapsedMilliseconds,
SearchTerm = searchTerm,
NumberOfItemsFound = posts.Count,
SearchResult = _postModelFactory.PreparePostCardViewModel(posts, currentUser, Url),
ShowAdvancedSearchPanel = false,
CardViewStyles = ViewStyles.Small,
};
return(View("Index", viewModel));
}
public void GetField_CanGetFieldOfCorrectType()
{
var fieldName = Guid.NewGuid().ToString();
var submitContext = GetSubmitContext();
foreach (var fieldType in FieldTypes)
{
submitContext.SourceMetaData.Add(
new SubmissionMetaDataModel()
{
Name = fieldName,
Type = fieldType,
Value = "Test"
}
);
}
foreach (var filterType in FilterTypes)
{
var fieldType = FilterHelpers.GetFieldType(new SearchTermModel()
{
FieldType = filterType
});
var filter = new SearchTermModel()
{
FieldName = GetSourceFieldName(Guid.NewGuid(), fieldName, fieldType),
FieldType = filterType,
FieldValue = "Test",
OperatorProperty = FilterConstants.CommonFieldOperators.Equal
};
var field = FilterHelpers.GetField(submitContext, filter, fieldType);
Assert.Equal(fieldName, field.Name);
Assert.Equal(fieldType, field.Type);
}
}
public static MatchResult MatchesFilter(SubmitContext submitContext, SearchTermModel filter)
{
var fieldType = GetFieldType(filter);
var field = GetField(submitContext, filter, fieldType);
if (field != null && field.Type != fieldType)
{
throw new ValidationException($"Field [{field.Name}] has FieldType [{field.Type}] and does not match Filter's FieldType [{filter.FieldType}]");
}
var result = false;
switch (filter.FieldType)
{
case FilterConstants.FilterFieldTypes.BooleanType:
{
result = BooleanFilter.MatchesFilter(field, filter);
break;
}
case FilterConstants.FilterFieldTypes.DateType:
{
result = DateTimeFilter.MatchesFilter(field, filter);
break;
}
case FilterConstants.FilterFieldTypes.NumericalType:
{
result = NumericalFilter.MatchesFilter(field, filter);
break;
}
case FilterConstants.FilterFieldTypes.StringType:
{
result = StringFilter.MatchesFilter(field, filter);
break;
}
default:
{
throw new NotImplementedException($"Filter for FieldName [{filter.FieldName}] has invalid FieldType [{filter.FieldType}]");
}
}
if (!result)
{
return(new MatchResult()
{
Result = false,
MatchReason = $"Field [{field?.Name ?? "<Null>"}] " +
$"Value [{field?.Value ?? "<Null>"}] " +
$"failed to match Filter: " +
$"Field Name {filter.FieldName} " +
$"Type [{filter.FieldType}] " +
$"Operator [{filter.OperatorProperty}] " +
$"Value [{filter?.FieldValue ?? "<Null>"}]"
});
}
return(new MatchResult()
{
Result = true,
MatchReason = $"Field [{field?.Name ?? "<Null>"}] " +
$"Value [{field?.Value ?? "<Null>"}] " +
$"matched Filter: " +
$"Field Name {filter.FieldName} " +
$"Type [{filter.FieldType}] " +
$"Operator [{filter.OperatorProperty}] " +
$"Value [{filter?.FieldValue ?? "<Null>"}]"
});
}
