private void SetSearchResults(ICollection <Course> results = null, bool faulted = false)
{
_dispatcher.ExecuteOnUiThread(() =>
{
FoundCourses.Clear();
if (faulted)
{
SearchStatus = SearchStatus.Faulted;
return;
}
if (SearchValue.IsNullOrEmpty())
{
SearchStatus = SearchStatus.Inactive;
return;
}
if (results == null || !results.Any())
{
SearchStatus = SearchStatus.NoResults;
return;
}
SearchStatus = SearchStatus.ResultsAvailable;
results.ForEach(c => FoundCourses.Add(c));
});
}
public void EnumParamterValidationTest(ResourceId resource, VerificationCaseType testCase, PrivateApiResponseCode expectedCode, Action <SearchRequest, Func <string, string> > requestUpdater, string caseDescription)
{
var request = SearchRequestComposer.GetBuilderWithRestrictions(resource).
BooleanFilter(OperatorType.And, new List <SearchFilter>
{
new SearchFilter
{
Area = "TEXT",
SplitMode = "AND",
SearchType = "COND_FREEWORD",
Operator = "IN",
Value = SearchValue.CreateConst("TEST")
},
new SearchFilter
{
Operator = "=",
SearchType = "COND_DATE2",
Timezone = "UTC",
Field = new SearchField
{
Type = "FIELD",
Route = $"{resource}.A_TestDate1"
},
Value = SearchValue.CreatePeriod("+P2Y", "DAY")
}
});
request.Conditions.OrderBy.First().Direction = "DESC";
PerformValidationTest(request, resource, testCase, expectedCode, requestUpdater);
}
private async Task UpdateSearchResultsAsync(string searchQuery)
{
if (SearchStatus == SearchStatus.Searching)
{
_searchTaskCancellationSource.Cancel();
}
if (SearchValue.IsNullOrWhiteSpace())
{
SetSearchResults();
return;
}
SearchStatus = SearchStatus.Searching;
_searchTaskCancellationSource?.Dispose();
_searchTaskCancellationSource = new CancellationTokenSource();
await Task.Run(async() =>
{
try
{
var result = await _courseService.SearchCoursesAsync(searchQuery).ConfigureAwait(true);
SetSearchResults(result);
}
catch (DataSourceException e)
{
LoggingService.Report(e.InnerException ?? e, this);
SetSearchResults(null, true);
}
}, _searchTaskCancellationSource.Token).ConfigureAwait(true);
}
// GET: /<controller>/
public IActionResult Index()
{
getDB.GetSeoul(DateTime.Now);
getDB.GetPolice(DateTime.Now, DateTime.Now, 100);
List <string> cateList = new List <string>();
using (NoteDBContext db = new NoteDBContext())
{
var dv = db.Found;
foreach (var a in dv)
{
cateList.Add(a.Found_BigCate);
}
}
cateList = cateList.Distinct().ToList();
List <SelectListItem> selectlist = new List <SelectListItem>();
foreach (string s in cateList)
{
selectlist.Add(new SelectListItem
{
Value = s,
Text = s
});
}
SearchValue sv = new SearchValue();
sv.cateList = selectlist;
return(View(sv));
}
public static void VerifySearchByDateField(ResourceId resource, ValidTestCases testCase, string fieldName, Directions direction, string currentDateTime, string timezone, int numRecords, HrbcRecordCreator hrbcRecordCreator)
{
SearchValue searchValue1 = null;
SearchValue searchValue2 = null;
DateTime dateTimeGreater = DateTime.Parse(currentDateTime);
DateTime dateTimeLess = DateTime.Parse(currentDateTime);
if (testCase == ValidTestCases.EqualsTo)
{
searchValue1 = searchValue2 = SearchValue.CreateDate(currentDateTime);
}
else
if (testCase == ValidTestCases.Greater)
{
searchValue1 = SearchValue.CreateDate(currentDateTime);
searchValue2 = SearchValue.CreateDate(dateTimeGreater.AddMinutes(numRecords - 1).ToString(SearchConstants.SearchApiFullDateTemplate));
}
else
{
searchValue2 = SearchValue.CreateDate(currentDateTime);
searchValue1 = SearchValue.CreateDate(dateTimeLess.AddMinutes(-numRecords).ToString(SearchConstants.SearchApiFullDateTemplate));
}
var request = SearchRequestComposer.GetBuilderWithRestrictions(resource).DateFilter($"{resource.ToString()}.{fieldName}", OperatorType.Between, timezone, searchValue1, searchValue2);
request.Conditions.OrderBy = GetOrderByType(resource, fieldName, direction);
var handler = new DefaultManager();
var response = handler.Send <SearchResponse>(request);
PrAssert.That(response, PrIs.SuccessfulResponse());
Assertions[direction](response.Result.Items, resource, hrbcRecordCreator, numRecords);
}
public IActionResult Search(SearchValue model, int page = 1)
{
List <Found> founds = new List <Found>();
using (NoteDBContext db = new NoteDBContext())
{
var dbList = db.Found;
var searchList = from a in dbList
where a.Found_DateTime >= model.Start_date
where a.Found_DateTime <= model.End_date
where a.Found_BigCate == model.Value
select a;
searchList = searchList.OrderByDescending(data => data.Found_DateTime);
foreach (var found in searchList)
{
founds.Add(new Found
{
Found_id = found.Found_id,
Found_data = found.Found_data,
Found_BigCate = found.Found_BigCate,
Found_DateTime = found.Found_DateTime,
Found_Description = found.Found_Description,
Found_GetPosition = found.Found_GetPosition,
Found_ImageURL = found.Found_ImageURL,
Found_Name = found.Found_Name,
Found_SmallCate = found.Found_SmallCate
});
}
}
ViewBag.sDate = model.Start_date;
ViewBag.eDate = model.End_date;
ViewBag.cateValue = model.Value;
return(View(founds.ToPagedList(page, 10)));
}
private void Setup()
{
AddFilter(PropertyFilterRx, GetValue);
AddFilter("p", GetValue, s => s, StringComparison.OrdinalIgnoreCase);
SearchValue.SetupEngine(this);
SetSearchDataCallback(GetSearchableData, StringComparison.OrdinalIgnoreCase);
}
protected void Page_Load(object sender, EventArgs e)
{
if (!IsPostBack)
{
BindData();
}
txtValue = SearchValue.ToString();
}
public void ResourceRouteParamterValidationTest(ResourceId resource, VerificationCaseType testCase, PrivateApiResponseCode expectedCode, Action <SearchRequest, Func <string, string> > requestUpdater, string caseDescription)
{
var request = SearchRequestComposer.GetBuilder(resource, $"{(int)resource}")
.Filter(searchType: SearchRequestComposer.SearchTypeMap[SearchFilterType.NumOperator],
field: $"{resource.ToString()}.P_Id",
op: SearchRequestComposer.OperatorTypeMap[OperatorType.Eq],
value: SearchValue.CreateConst("1234"));
PerformValidationTest(request, resource, testCase, expectedCode, requestUpdater);
}
public static SearchFilter SubQueryCondition(ResourceId resource, string fieldName, string operatorText)
{
return(new SearchFilter
{
Field = new SearchField($"{resource}.{fieldName}"),
SearchType = SearchRequestComposer.SearchTypeMap[SearchFilterType.Subquery],
Operator = SearchRequestComposer.OperatorTypeMap[OperatorType.In],
Value = SearchValue.CreateSubquery(resource, $"{resource}.P_Id", SearchFilter.CreateText($"{resource}.{fieldName}", operatorText, "Test", null))
});
}
public SearchRequest SubqueryFilter(string fieldName, ResourceId subqueryResourceId, string subqueryField, SearchFilter condition, IEnumerable <SearchConditions.SearchOrdering> orderBy = null)
{
_request.Conditions.Filter = new SearchFilter
{
Field = new SearchField(fieldName),
SearchType = SearchTypeMap[SearchFilterType.Subquery],
Operator = OperatorTypeMap[OperatorType.In],
Value = SearchValue.CreateSubquery(subqueryResourceId, subqueryField, condition, orderBy)
};
return(_request);
}
private void FilterList()
{
if (!string.IsNullOrEmpty(SearchValue))
{
var list = from main in MainCasePendingList
where main.CustomerName.Contains(SearchValue.ToUpper())
select main;
CasePendingList = new ObservableCollection <CasePendingModel> (list);
}
else
{
CasePendingList = MainCasePendingList;
}
}
private static Dictionary <string, Func <SearchRequest> > PrepareDateMinMaxCases(ResourceId resource, Func <string> fullFieldName, DateTime testValue)
{
var minDateValue = SearchValue.CreateDate((testValue.AddMonths(-1)).ToString(SearchConstants.SearchApiFullDateTemplate));
var maxDateValue = SearchValue.CreateDate((testValue.AddMonths(1)).ToString(SearchConstants.SearchApiFullDateTemplate));
var minPeriodValue = SearchValue.CreatePeriod(System.Xml.XmlConvert.ToString(Truncate(testValue.AddMonths(-1) - DateTime.Now)));
var maxPeriodValue = SearchValue.CreatePeriod(System.Xml.XmlConvert.ToString(Truncate(testValue.AddMonths(1) - DateTime.Now)));
return(SearchConstants.BetweenOperator.Select(op => new Dictionary <string, Func <SearchRequest> >
{
[op.GetEnumAttributeValue <EnumMemberAttribute>("Value") + " 2 Dates"] = () => SearchRequestComposer.GetBuilderWithRestrictions(resource).DateFilter(fullFieldName(), op, DefaultTimezone, minDateValue, maxDateValue),
[op.GetEnumAttributeValue <EnumMemberAttribute>("Value") + " 2 Periods"] = () => SearchRequestComposer.GetBuilderWithRestrictions(resource).DateFilter(fullFieldName(), op, DefaultTimezone, minPeriodValue, maxPeriodValue),
[op.GetEnumAttributeValue <EnumMemberAttribute>("Value") + " Date and Period"] = () => SearchRequestComposer.GetBuilderWithRestrictions(resource).DateFilter(fullFieldName(), op, DefaultTimezone, minDateValue, maxPeriodValue)
}).SelectMany(x => x).ToDictionary(x => x.Key == "= Date and Period" ? $"{x.Key} {ImportantCaseMarker }" : x.Key, x => x.Value));
}
private static Dictionary <string, Func <SearchRequest> > PrepareDateInCases(ResourceId resource, Func <string> fullFieldName, DateTime testValue, DateTime altTestValue)
{
var dateSearchValue = SearchValue.CreateDate((testValue).ToString(SearchConstants.SearchApiFullDateTemplate));
var altDateSearchValue = SearchValue.CreateDate((altTestValue).ToString(SearchConstants.SearchApiFullDateTemplate));
var periodSearchValue = SearchValue.CreatePeriod(System.Xml.XmlConvert.ToString(Truncate(testValue - DateTime.Now)), "HOUR");
var altPeriodSearchValue = SearchValue.CreatePeriod(System.Xml.XmlConvert.ToString(Truncate(altTestValue - DateTime.Now)), "HOUR");
return(SearchConstants.NumericOperators.Select(op => new Dictionary <string, Func <SearchRequest> >
{
[op.GetEnumAttributeValue <EnumMemberAttribute>("Value") + " 2 Dates"] = () => SearchRequestComposer.GetBuilderWithRestrictions(resource).DateFilter(fullFieldName(), op, DefaultTimezone, new[] { dateSearchValue, altDateSearchValue }),
[op.GetEnumAttributeValue <EnumMemberAttribute>("Value") + " 2 Periods"] = () => SearchRequestComposer.GetBuilderWithRestrictions(resource).DateFilter(fullFieldName(), op, DefaultTimezone, new[] { periodSearchValue, altPeriodSearchValue }),
[op.GetEnumAttributeValue <EnumMemberAttribute>("Value") + " Date and Period"] = () => SearchRequestComposer.GetBuilderWithRestrictions(resource).DateFilter(fullFieldName(), op, DefaultTimezone, new[] { dateSearchValue, altPeriodSearchValue })
}).SelectMany(x => x).ToDictionary(x => x.Key == "= Date and Period" ? $"{x.Key} {ImportantCaseMarker }" : x.Key, x => x.Value));
}
private bool DoesSystemMatchSearch(StarSystem system, SearchValue search)
{
if (string.IsNullOrEmpty(search.Value))
{
return(true);
}
bool matches;
switch (search.Type)
{
case "name":
matches = system.Name.ToLower().StartsWith(search.Value);
break;
case "for":
case "employer":
matches = system.Def.ContractEmployerIDList.Any(faction => DoesFactionMatchSearch(faction, search.Value));
break;
case "against":
case "target":
matches = system.Def.ContractTargetIDList.Any(faction => DoesFactionMatchSearch(faction, search.Value));
break;
case "tag":
matches = system.Tags.Any(tagID => DoesTagMatchSearch(tagID, search.Value));
break;
case "":
matches = system.Name.ToLower().StartsWith(search.Value) ||
system.Def.ContractEmployerIDList.Any(faction => DoesFactionMatchSearch(faction, search.Value)) ||
system.Tags.Any(tagID => DoesTagMatchSearch(tagID, search.Value));
break;
default:
matches = false;
break;
}
return(search.Inverted ? !matches : matches);
}
private Expression GetFilteringExpression(ParameterExpression parameterExpression)
{
var memberAccessInfo = GetMemberAccessInfo(parameterExpression);
var targetPropertyType = memberAccessInfo.MemberAccessExpression.Type;
var searchValue = SearchValue;
var searchValueType = SearchValue?.GetType();
if (searchValueType != null && searchValueType != targetPropertyType)
{
bool searchValueCanBeConverted = TypesSupportedConversion.ContainsKey(searchValueType) && TypesSupportedConversion[searchValueType].Any(t => t == targetPropertyType);
if (!searchValueCanBeConverted)
{
throw new Exception($"Types missmatch. Property {PropertyName} type of {targetPropertyType} can not be compared against the search value type of {searchValueType}");
}
try
{
var convertedSearchValue = Convert.ChangeType(SearchValue, targetPropertyType);
searchValue = convertedSearchValue;
}
catch (Exception ex)
{
throw new Exception($"Type conversion failed. Value '{searchValue}' can not be converted to the type {targetPropertyType} of the property {PropertyName}");
}
}
var searchValueExpression = Expression.Constant(searchValue);
var filteringExpression = Operator.ToExpression(memberAccessInfo.MemberAccessExpression, searchValueExpression);
if (memberAccessInfo.ChecksAgainsNullExpression != null)
{
return(Expression.AndAlso(memberAccessInfo.ChecksAgainsNullExpression, filteringExpression));
}
return(filteringExpression);
}
void FilterData()
{
if (OriginalDatas != null && OriginalDatas.Any())
{
var key = SearchValue.Trim().ToLower();
var FilterData = OriginalDatas.Where(e => e.AlertType.ToLower().Contains(AlertType.ToLower()) &&
e.UpsName.ToLower().Contains(UpsName.ToLower()) &&
e.AlertValue.ToString().Contains(AlertValue) &&
e.AlarmDate.Contains(AlarmDateValue) &&
e.ResolvedDate.ToString().Contains(ResolvedDateValue) &&
e.ResolveValue.ToString().Contains(ResolveValue) &&
(e.AlertType.ToLower().Contains(key) ||
e.UpsName.ToLower().Contains(key) ||
e.StringName.ToLower().Contains(key) ||
e.AlertValue.ToString().Contains(key) ||
e.ResolveValue.ToString().Contains(key))
).ToList();
AlarmDatas = new ObservableCollection <AlarmItemViewModel>(FilterData);
Alarms = new ObservableCollection <AlarmItemViewModel>(AlarmDatas.Take(AlarmDatas.Count > AppConstant.PAGE_SIZE ? AppConstant.PAGE_SIZE : AlarmDatas.Count));
}
}
public override string GetSql()
{
if (SearchValue.Length > 0)
{
if (SearchExactly)
{
return(string.Format("(hivw_Quick_User_Search_Base.{0} = N';{1};')", strDBFieldName, SearchValue.Replace("'", "''")));
}
else
{
return(string.Format("(hivw_Quick_User_Search_Base.{0} LIKE N'%;{1};%')", strDBFieldName, SearchValue.Replace("'", "''")));
}
}
else
{
return(string.Empty);
}
}
public void SearchInputBox(string searchInput)
{
SearchValue.Clear();
SearchValue.SendKeys(searchInput);
}
public SearchRequest DateFilter(string fieldName, OperatorType op, string timezone, SearchValue min, SearchValue max)
{
_request.Conditions.Filter = SearchFilter.CreateDateMinMax(fieldName, timezone, OperatorTypeMap[op], min, max);
return(_request);
}
public SearchRequest Filter(string searchType, string op = null, string field = null, object value = null, IEnumerable <object> values = null, string timezone = null, SearchValue min = null, SearchValue max = null, string lang = null, string splitMode = null, string area = null)
{
_request.Conditions.Filter = new SearchFilter
{
Field = field == null ? null : new SearchField(field),
Operator = op,
SearchType = searchType,
Timezone = timezone,
Min = min,
Max = max,
Area = area,
Lang = lang,
SplitMode = splitMode,
Value = value,
Values = values
};
return(_request);
}
public SearchRequest DateFilter(string fieldName, OperatorType op, string timezone, string period, string crop)
{
_request.Conditions.Filter = SearchFilter.CreateDate(fieldName, timezone, OperatorTypeMap[op], period == null ? SearchValue.Null : SearchValue.CreatePeriod(period, crop));
return(_request);
}
public SearchRequest DateFilter(string fieldName, OperatorType op, string timezone, string date)
{
_request.Conditions.Filter = SearchFilter.CreateDate(fieldName, timezone, OperatorTypeMap[op], date == null ? SearchValue.Null : SearchValue.CreateDate(date));
return(_request);
}
public override string GetSql()
{
if (SearchValue.Length > 0)
{
if (SearchRangeKm == 0)
{
return(string.Format("NOT (hivw_Quick_User_Search_Base.Zip = '') AND (ISNULL(dbo.hifu_PLZ_Distance(hivw_Quick_User_Search_Base.Zip, 'ch', '{0}', 'ch'), 999999) <= {1})", SearchValue.Replace("'", "''"), 1));
}
else
{
return(string.Format("NOT (hivw_Quick_User_Search_Base.Zip = '') AND (ISNULL(dbo.hifu_PLZ_Distance(hivw_Quick_User_Search_Base.Zip, 'ch', '{0}', 'ch'), 999999) <= {1})", SearchValue.Replace("'", "''"), SearchRangeKm));
}
}
else
{
return(string.Empty);
}
}
public override string GetSql()
{
if (SearchValue.Length > 0)
{
if (SearchExactly)
{
return(string.Format("(hivw_Quick_User_Search_Base.City = N'{0}')", SearchValue.Replace("'", "''")));
}
else
{
return(string.Format("(hivw_Quick_User_Search_Base.City LIKE N'%{0}%')", SearchValue.Replace("'", "''")));
}
}
else
{
return(string.Empty);
}
}
private CertificatePaged GetCertificates()
{
IEnumerable <Certificate> filteredCertificates = _certificates.Where(x => (string.IsNullOrWhiteSpace(SearchValue) || x.Course.Title.ToLower().Contains(SearchValue.ToLower())) && (ActualCategoryIndex == -1 || Categories[ActualCategoryIndex].CertificateCodes.Contains(x.Code)));
CertificatePaged filteredCertificatePages = (CertificatePaged)_certificates.Clone();
filteredCertificatePages.Add(filteredCertificates);
return(filteredCertificatePages);
}
private Expression <Func <Patient, bool> > RelatedDataOrFilterQuery()
{
var searchKlass = Field.Split(".")[0];
var searchField = Field.Split(".")[1];
switch (SearchClass)
{
case "PatientDiagnosis": // pd.GetType().GetProperty(searchField).GetValue(m.PatientDiagnoses, null).ToString() == SearchValue)
Predicate = Predicate.Or(m => m.PatientDiagnoses.
Where(pd => pd.GetType().GetProperty(searchField).GetValue(pd, null).ToString() == SearchValue).
Select(p => p.PatientId.ToString()).
Contains(m.ID.ToString())
);
break;
case "PatientDrug":
if (Field.Contains("Date"))
{
string dateField = Field.Split(".")[2];
switch (SearchCriteria)
{
case "GreaterThan":
Predicate = Predicate.Or(m => m.PatientDrugs.
Where(pd => (Convert.ToDateTime(pd.GetType().GetProperty(dateField).GetValue(pd, null)).Date > Convert.ToDateTime(SearchValue).Date)).
Select(p => p.PatientId.ToString()).
Contains(m.ID.ToString())
);
break;
case "SmallerThan":
Predicate = Predicate.Or(m => m.PatientDrugs.
Where(pd => (Convert.ToDateTime(pd.GetType().GetProperty(dateField).GetValue(pd, null)).Date < Convert.ToDateTime(SearchValue).Date)).
Select(p => p.PatientId.ToString()).
Contains(m.ID.ToString())
);
break;
case "Exact":
Predicate = Predicate.Or(m => m.PatientDrugs.
Where(pd => (Convert.ToDateTime(pd.GetType().GetProperty(dateField).GetValue(pd, null)).Date == Convert.ToDateTime(SearchValue).Date)).
Select(p => p.PatientId.ToString()).
Contains(m.ID.ToString())
);
break;
}
}
else
{
Predicate = Predicate.Or(m => m.PatientDrugs.
Where(pd => pd.GetType().GetProperty(searchField).GetValue(pd, null).ToString() == SearchValue).
Select(p => p.PatientId.ToString()).
Contains(m.ID.ToString())
);
}
break;
case "Patient":
Predicate = Predicate.Or(m => m.PatientStatusId.ToString() == SearchValue);
break;
case "PatientRadiologyFinidng":
Predicate = Predicate.Or(m => m.PatientRadiologyFindings.
Where(pd => pd.GetType().GetProperty(searchField).GetValue(pd, null).ToString() == SearchValue).
Select(p => p.PatientId.ToString()).
Contains(m.ID.ToString())
);
break;
case "PatientMedicalTrial":
Predicate = Predicate.Or(m => m.MedicalTrials.
Where(pd => pd.GetType().GetProperty(searchField).GetValue(pd, null).ToString() == SearchValue).
Select(p => p.PatientId.ToString()).
Contains(m.ID.ToString())
);
break;
case "PatientSurgery":
Predicate = Predicate.Or(m => m.PatientSurgeries.
Where(pd => pd.GetType().GetProperty(searchField).GetValue(pd, null).ToString() == SearchValue).
Select(p => p.PatientId.ToString()).
Contains(m.ID.ToString())
);
break;
case "PatientAllergicIntoleranceItem":
var searchId = SearchValue.Split("_")[0];
var searchSubKlass = SearchValue.Split("_")[1];
Predicate = Predicate.Or(m => m.PatientAllergicIntoleranceItems.
Where(pd => pd.GetType().GetProperty(searchField).GetValue(pd, null).ToString() == searchId && pd.AllergyIntoleranceItemType == searchSubKlass).
Select(p => p.PatientId.ToString()).
Contains(m.ID.ToString())
);
break;
case "PatientNACDates":
if (Field.Contains("Date"))
{
string dateField = Field.Split(".")[1];
switch (SearchCriteria)
{
}
}
break;
}
return(Predicate);
}
private SearchValue GetSearchValue(string searchValue)
{
_context.SaveChanges();
Expression<Func<SearchValue, bool>> expr = a => a.Value == searchValue;
var existingvalue = _context.SearchValues.Where(expr).FirstOrDefault();
if (existingvalue != null)
{
return existingvalue;
}
var value = new SearchValue {Value = searchValue};
_context.AddObject("SearchValues", value);
_context.SaveChanges();
return value;
}
