public void Build <T>(QueryBuilderContext <T> ctx) where T : class, new()
{
var softDeletesQuery = ctx.GetSourceAs <ISoftDeletesQuery>();
if (softDeletesQuery == null || softDeletesQuery.IncludeSoftDeletes)
{
return;
}
var idsQuery = ctx.GetSourceAs <IIdentityQuery>();
var opt = ctx.GetOptionsAs <IElasticQueryOptions>();
if (opt == null || !opt.SupportsSoftDeletes || (idsQuery != null && idsQuery.Ids.Count > 0))
{
return;
}
var missingFilter = new MissingFilter {
Field = Deleted
};
var termFilter = new TermFilter {
Field = Deleted, Value = softDeletesQuery.IncludeSoftDeletes
};
ctx.Filter &= (new FilterContainer(missingFilter) || new FilterContainer(termFilter));
}
public async Task <int> Count(TermFilter filter)
{
IQueryable <TermDAO> termDAOs = examRegContext.Term.AsNoTracking();
termDAOs = DynamicFilter(termDAOs, filter);
return(await termDAOs.CountAsync());
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
var j = JObject.Load(reader);
if (j == null || !j.HasValues)
return null;
ITermFilter filter = new TermFilter();
foreach (var jv in j)
{
switch (jv.Key)
{
case "boost":
filter.Boost = jv.Value.Value<double?>();
break;
case "_cache":
filter.Cache = jv.Value.Value<bool?>();
break;
case "_cacheKey":
case "_cache_key":
filter.CacheKey = jv.Value.Value<string>();
break;
case "_name":
filter.FilterName = jv.Value.Value<string>();
break;
default:
var field = jv.Key;
filter.Field = field;
filter.Value = jv.Value.Value<string>();
break;
}
}
return filter;
}
public async Task ShouldSearch()
{
/// Arrange
var channelIds = new List <string> {
"rootChannel"
};
var searchFieldPath =
nameof(ContentDetail.Audit).ToLowerCamelCase() + "." +
nameof(UserAudit.CreationDate).ToLowerCamelCase();
var sortInfos = new List <SortInfo>
{
new SortInfo {
Direction = SortDirection.Asc, Field = searchFieldPath
}
};
var filter = new TermFilter {
Field = "contentSchemaId", Term = "ImageMetadata"
};
var request = new ContentSearchRequest
{
ChannelIds = channelIds,
SearchString = "*",
Sort = sortInfos,
Filter = filter,
Start = 0
};
/// Act
ContentSearchResult result = await _client.Contents.SearchAsync(request);
/// Assert
Assert.True(result.Results.Count > 0);
}
public override ITypeSearch <FindProduct> ApplyFilter(ITypeSearch <FindProduct> query)
{
if (string.IsNullOrEmpty(FieldName) == false)
{
string fullFieldName = query.Client.GetFullFieldName(FieldName, typeof(double));
switch (FieldOperator)
{
case NumericOperatorSelectionFactory.OperatorNames.GreaterThan:
RangeFilter <double> greaterThanFilter = RangeFilter.Create(fullFieldName, FieldValue, double.MaxValue);
greaterThanFilter.IncludeLower = false;
greaterThanFilter.IncludeUpper = true;
query = query.Filter(greaterThanFilter);
break;
case NumericOperatorSelectionFactory.OperatorNames.LessThan:
RangeFilter <double> lessThanFilter = RangeFilter.Create(fullFieldName, double.MinValue, FieldValue);
lessThanFilter.IncludeLower = false;
lessThanFilter.IncludeUpper = true;
query = query.Filter(lessThanFilter);
break;
default:
case NumericOperatorSelectionFactory.OperatorNames.Equal:
var termFilter = new TermFilter(fullFieldName, FieldValue);
query = query.Filter(termFilter);
break;
}
}
return(query);
}
public static object MapTo(this TermFilter termFilter, object obj)
{
var propertyInfo = obj.GetType().GetProperty(termFilter.FieldName.ToPascalCase());
if (propertyInfo != null)
{
object value = termFilter.Values;
if (value != null)
{
if (propertyInfo.PropertyType.IsArray)
{
var elementType = propertyInfo.PropertyType.GetElementType();
var actualValues = Array.CreateInstance(elementType, termFilter.Values.Count);
for (var i = 0; i < termFilter.Values.Count; i++)
{
actualValues.SetValue(termFilter.Values[i].ChangeType(elementType), i);
}
value = actualValues;
}
else
{
value = termFilter.Values.FirstOrDefault().ChangeType(propertyInfo.PropertyType);
}
}
propertyInfo.SetValue(obj, value, null);
}
return(obj);
}
public void SerializerTermFilter()
{
JsonSerializer jsonSerializer = new JsonSerializer();
TermFilter termFilter = new TermFilter("filterfield", "filtervalue");
string jsonString = jsonSerializer.Serialize(termFilter);
Console.WriteLine(jsonString);
}
public async Task <Term[]> GetTermsAsync(string taxonomy, TermFilter filter)
{
return(await Task.Factory.FromAsync
(
WordPressService.BeginGetTerms(WordPressSiteConfig.BlogId, WordPressSiteConfig.Username,
WordPressSiteConfig.Password, taxonomy, filter),
WordPressService.EndGetTerms
));
}
public IndexSearchRequestBuilder ParseFacets(ISearchPhraseParser phraseParser, string facetPhrase, IList <AggregationRequest> predefinedAggregations = null)
{
if (phraseParser == null)
{
throw new ArgumentNullException(nameof(phraseParser));
}
SearchRequest.Aggregations = predefinedAggregations ?? new List <AggregationRequest>();
if (string.IsNullOrEmpty(facetPhrase))
{
return(this);
}
//TODO: Support aliases for Facet expressions e.g price.usd[TO 200) as price_below_200
//TODO: Need to create a new Antlr file with g4-lexer rules and generate parser especially for facets expression that will return proper AggregationRequests objects
var parseResult = phraseParser.Parse(facetPhrase);
//Term facets
if (!string.IsNullOrEmpty(parseResult.Keyword))
{
var termFacetExpressions = parseResult.Keyword.Split(" ");
parseResult.Filters.AddRange(termFacetExpressions.Select(x => new TermFilter
{
FieldName = x,
Values = new List <string>()
}));
}
SearchRequest.Aggregations = parseResult.Filters
.Select <IFilter, AggregationRequest>(filter =>
{
FilterSyntaxMapper.MapFilterAdditionalSyntax(filter);
return(filter switch
{
RangeFilter rangeFilter => new RangeAggregationRequest
{
Id = filter.Stringify(),
FieldName = rangeFilter.FieldName,
Values = rangeFilter.Values.Select(x => new RangeAggregationRequestValue
{
Id = x.Stringify(),
Lower = x.Lower,
Upper = x.Upper,
IncludeLower = x.IncludeLower,
IncludeUpper = x.IncludeUpper
}).ToList()
},
TermFilter termFilter => new TermAggregationRequest
{
FieldName = termFilter.FieldName,
Id = filter.Stringify(),
Filter = termFilter
},
_ => null,
});
})
public void TestCachability()
{
TermFilter a = TermFilter(@"field1", @"a");
var cachedFilters = new JCG.HashSet <Filter>();
cachedFilters.Add(a);
assertTrue(@"Must be cached", cachedFilters.Contains(TermFilter(@"field1", @"a")));
assertFalse(@"Must not be cached", cachedFilters.Contains(TermFilter(@"field1", @"b")));
assertFalse(@"Must not be cached", cachedFilters.Contains(TermFilter(@"field2", @"a")));
}
public Admin LoginAdmin(string userName, string password)
{
if (String.IsNullOrWhiteSpace(userName) || String.IsNullOrWhiteSpace(password))
{
throw new Exception(ErrorConstants.REQUIRED_FIELD_EMPTY);
}
try
{
var elasticClient = GetElasticClient();
var userNameFilter = new TermFilter()
{
Field = ConstAdmin.USER_NAME,
Value = userName
};
var loginFilters = new List <FilterContainer>();
loginFilters.Add(userNameFilter);
var loginFilter = new AndFilter();
loginFilter.Filters = loginFilters;
var loginResponse = elasticClient.Search <Admin>(s => s
.Index(ElasticMappingConstants.INDEX_NAME)
.Type(ElasticMappingConstants.TYPE_ADMIN)
.Filter(loginFilter)
.Size(1));
var admin = new Admin();
if (loginResponse.Total > 0)
{
foreach (IHit <Admin> hit in loginResponse.Hits)
{
admin = hit.Source;
}
if (!PasswordHash.ValidatePassword(password, admin.password, admin.salt))
{
throw new Exception(ErrorConstants.WRONG_PASSWORD);
}
return(admin);
}
else
{
return(null);
}
}
catch (Exception e)
{
Console.Error.WriteLine(e.GetBaseException().Message);
return(null);
}
}
public bool CreateAdmin(Admin admin, string userName)
{
if (String.IsNullOrWhiteSpace(userName))
{
throw new Exception(ErrorConstants.REQUIRED_FIELD_EMPTY);
}
if (admin == null || admin.type != (int)BillingEnums.USER_TYPE.SUPER_ADMIN)
{
throw new Exception(ErrorConstants.NO_PREVILAGE);
}
var newAdmin = new Admin()
{
id = Guid.NewGuid(),
username = userName,
type = (int)BillingEnums.USER_TYPE.ADMIN,
created_at = DateTime.UtcNow
};
try
{
var elasticClient = GetElasticClient();
var userNameFilter = new TermFilter()
{
Field = ConstAdmin.USER_NAME,
Value = userName
};
var adminList = elasticClient.Search <Admin>(s => s
.Index(ElasticMappingConstants.INDEX_NAME)
.Type(ElasticMappingConstants.TYPE_ADMIN)
.Filter(userNameFilter)
);
if (adminList.Total > 0)
{
throw new Exception(ErrorConstants.ADMIN_USERNAME_ALREADY_TAKEN);
}
var response = elasticClient.Index <Admin>(newAdmin, i => i
.Index(ElasticMappingConstants.INDEX_NAME)
.Type(ElasticMappingConstants.TYPE_ADMIN)
);
return(response.Created);
}
catch (Exception e)
{
Console.Error.WriteLine(e.GetBaseException().Message);
throw e;
}
}
private static Filter CreateTermFilter(TermFilter termFilter, ICollection <string> availableFields)
{
Filter result = null;
if (termFilter?.FieldName != null && termFilter.Values != null)
{
var isBooleanField = availableFields.Contains(LuceneSearchHelper.GetBooleanFieldName(termFilter.FieldName));
var values = termFilter.Values.Select(v => GetFilterValue(v, isBooleanField)).ToArray();
var fieldName = LuceneSearchHelper.ToLuceneFieldName(termFilter.FieldName);
result = CreateTermsFilter(fieldName, values);
}
return(result);
}
protected virtual IFilter ConvertAttributeFilter(AttributeFilter attributeFilter, IList <string> valueIds)
{
var knownValues = attributeFilter.Values
?.Where(v => valueIds.Contains(v.Id, StringComparer.OrdinalIgnoreCase))
.Select(v => v.Id)
.ToArray();
var result = new TermFilter
{
FieldName = attributeFilter.Key,
Values = knownValues != null && knownValues.Any() ? knownValues : valueIds,
};
return(result);
}
public void TestRandom()
{
Directory dir = NewDirectory();
RandomIndexWriter w = new RandomIndexWriter(
#if FEATURE_INSTANCE_TESTDATA_INITIALIZATION
this,
#endif
Random, dir);
int num = AtLeast(100);
var terms = new JCG.List <Term>();
for (int i = 0; i < num; i++)
{
string field = @"field" + i;
string str = TestUtil.RandomRealisticUnicodeString(Random);
terms.Add(new Term(field, str));
Document doc = new Document();
doc.Add(NewStringField(field, str, Field.Store.NO));
w.AddDocument(doc);
}
IndexReader reader = w.GetReader();
w.Dispose();
IndexSearcher searcher = NewSearcher(reader);
int numQueries = AtLeast(10);
for (int i = 0; i < numQueries; i++)
{
Term term = terms[Random.nextInt(num)];
TopDocs queryResult = searcher.Search(new TermQuery(term), reader.MaxDoc);
MatchAllDocsQuery matchAll = new MatchAllDocsQuery();
TermFilter filter = TermFilter(term);
TopDocs filterResult = searcher.Search(matchAll, filter, reader.MaxDoc);
assertEquals(filterResult.TotalHits, queryResult.TotalHits);
ScoreDoc[] scoreDocs = filterResult.ScoreDocs;
for (int j = 0; j < scoreDocs.Length; j++)
{
assertEquals(scoreDocs[j].Doc, queryResult.ScoreDocs[j].Doc);
}
}
reader.Dispose();
dir.Dispose();
}
protected override Expression VisitTypeBinary(TypeBinaryExpression node)
{
if (node.NodeType == ExpressionType.TypeIs)
{
var fieldName = conventions.FieldNameConvention.GetFieldName(node.Expression);
if (!string.IsNullOrEmpty(fieldName))
{
fieldName += ".";
}
fieldName += TypeHierarchyInterceptor.TypeHierarchyJsonPropertyName;
var typeHiearchyFilter = new TermFilter(fieldName,
TypeHierarchyInterceptor.GetTypeName(node.TypeOperand));
AddFilter(typeHiearchyFilter);
}
return(base.VisitTypeBinary(node));
}
/*private async Task<bool> ValidateExist(Term Term)
* {
* TermFilter filter = new TermFilter
* {
* Take = Int32.MaxValue,
* SubjectName = new StringFilter { Equal = Term.SubjectName },
* SemesterCode = new StringFilter { Equal = Term.SemesterCode }
* };
*
* int count = await UOW.TermRepository.Count(filter);
* if (count == 0)
* {
* Term.AddError(nameof(TermValidator), nameof(Term), ERROR.NotExisted);
* return false;
* }
* return true;
* }*/
private async Task <bool> ValidateId(Term Term)
{
TermFilter filter = new TermFilter
{
Id = new GuidFilter {
Equal = Term.Id
}
};
int count = await UOW.TermRepository.Count(filter);
if (count == 0)
{
Term.AddError(nameof(TermValidator), nameof(Term), ERROR.IdNotFound);
}
return(count == 1);
}
private static QueryContainer CreateTermFilter(TermFilter termFilter, Properties <IProperties> availableFields)
{
var termValues = termFilter.Values;
var field = availableFields.Where(kvp => kvp.Key.Name.EqualsInvariant(termFilter.FieldName)).Select(kvp => kvp.Value).FirstOrDefault();
if (field?.Type?.Name?.EqualsInvariant("boolean") == true)
{
termValues = termValues.Select(v => v.ToLowerInvariant()).ToArray();
}
return(new TermsQuery
{
Field = ElasticSearchHelper.ToElasticFieldName(termFilter.FieldName),
Terms = termValues
});
}
public void TestHashCodeAndEquals()
{
int num = AtLeast(100);
for (int i = 0; i < num; i++)
{
string field1 = @"field" + i;
string field2 = @"field" + i + num;
string value1 = TestUtil.RandomRealisticUnicodeString(Random);
string value2 = value1 + @"x";
TermFilter filter1 = TermFilter(field1, value1);
TermFilter filter2 = TermFilter(field1, value2);
TermFilter filter3 = TermFilter(field2, value1);
TermFilter filter4 = TermFilter(field2, value2);
var filters = new TermFilter[]
{
filter1, filter2, filter3, filter4
};
for (int j = 0; j < filters.Length; j++)
{
TermFilter termFilter = filters[j];
for (int k = 0; k < filters.Length; k++)
{
TermFilter otherTermFilter = filters[k];
if (j == k)
{
assertEquals(termFilter, otherTermFilter);
assertEquals(termFilter.GetHashCode(), otherTermFilter.GetHashCode());
assertTrue(termFilter.Equals(otherTermFilter));
}
else
{
assertFalse(termFilter.Equals(otherTermFilter));
}
}
}
TermFilter filter5 = TermFilter(field2, value2);
assertEquals(filter5, filter4);
assertEquals(filter5.GetHashCode(), filter4.GetHashCode());
assertTrue(filter5.Equals(filter4));
assertEquals(filter5, filter4);
assertTrue(filter5.Equals(filter4));
}
}
public void FillIsAppliedForItems_TermFilter_IsAppliedSetProperly(string termValue, object aggregationItemValue, bool expectedIsApplied)
{
// Arrange
var filter = new TermFilter()
{
Values = new string[] { termValue }
};
var aggregationItem = new AggregationItem()
{
Value = aggregationItemValue
};
// Act
filter.FillIsAppliedForItems(new[] { aggregationItem });
// Assert
Assert.Equal(expectedIsApplied, aggregationItem.IsApplied);
}
private IQueryable <TermDAO> DynamicOrder(IQueryable <TermDAO> query, TermFilter filter)
{
switch (filter.OrderType)
{
case OrderType.ASC:
switch (filter.OrderBy)
{
case TermOrder.SubjectName:
query = query.OrderBy(q => q.SubjectName);
break;
case TermOrder.SemesterCode:
query = query.OrderBy(q => q.Semester.StartYear);
break;
default:
query = query.OrderBy(q => q.CX);
break;
}
break;
case OrderType.DESC:
switch (filter.OrderBy)
{
case TermOrder.SubjectName:
query = query.OrderByDescending(q => q.SubjectName);
break;
case TermOrder.SemesterCode:
query = query.OrderByDescending(q => q.Semester.StartYear);
break;
default:
query = query.OrderByDescending(q => q.CX);
break;
}
break;
default:
query = query.OrderBy(q => q.CX);
break;
}
return(query.Skip(filter.Skip).Take(filter.Take));
}
private static string CreateTermFilter(TermFilter termFilter, IList <Field> availableFields)
{
string result;
var availableField = availableFields.Get(termFilter.FieldName);
if (availableField != null)
{
result = availableField.Type.ToString().StartsWith("Collection(")
? GetContainsFilterExpression(availableField, termFilter.Values)
: GetEqualsFilterExpression(availableField, termFilter.Values);
}
else
{
result = AzureSearchHelper.NonExistentFieldFilter;
}
return(result);
}
public override void BuildFilter <T>(object query, object options, ref FilterContainer container)
{
var softDeletesQuery = query as ISoftDeletesQuery;
if (softDeletesQuery == null)
{
return;
}
var opt = options as IQueryOptions;
if (opt == null || !opt.SupportsSoftDeletes)
{
return;
}
container &= new TermFilter {
Field = "deleted", Value = softDeletesQuery.IncludeSoftDeletes
};
}
public override void ExitAttributeFilter(Antlr.SearchPhraseParser.AttributeFilterContext context)
{
base.ExitAttributeFilter(context);
var fieldNameContext = context.GetChild <Antlr.SearchPhraseParser.FieldNameContext>(0);
var attributeValueContext = context.GetChild <Antlr.SearchPhraseParser.AttributeFilterValueContext>(0);
if (fieldNameContext != null && attributeValueContext != null)
{
var values = attributeValueContext.children.OfType <Antlr.SearchPhraseParser.StringContext>().ToArray();
var filter = new TermFilter
{
FieldName = Unescape(fieldNameContext.GetText()),
Values = values.Select(v => Unescape(v.GetText())).ToArray(),
};
Filters.Add(filter);
}
}
protected virtual TermFilter GetTermFilter(Antlr.SearchPhraseParser.AttributeFilterContext context)
{
var fieldNameContext = context.GetChild <Antlr.SearchPhraseParser.FieldNameContext>(0);
var attributeValueContext = context.GetChild <Antlr.SearchPhraseParser.AttributeFilterValueContext>(0);
if (fieldNameContext == null || attributeValueContext == null)
{
return(null);
}
var values = attributeValueContext.children.OfType <Antlr.SearchPhraseParser.StringContext>().ToArray();
var filter = new TermFilter
{
FieldName = Unescape(fieldNameContext.GetText()),
Values = values.Select(v => Unescape(v.GetText())).ToArray(),
};
return(filter);
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
var j = JObject.Load(reader);
if (j == null || !j.HasValues)
{
return(null);
}
ITermFilter filter = new TermFilter();
foreach (var jv in j)
{
switch (jv.Key)
{
case "boost":
filter.Boost = jv.Value.Value <double?>();
break;
case "_cache":
filter.Cache = jv.Value.Value <bool?>();
break;
case "_cacheKey":
case "_cache_key":
filter.CacheKey = jv.Value.Value <string>();
break;
case "_name":
filter.FilterName = jv.Value.Value <string>();
break;
default:
var field = jv.Key;
filter.Field = field;
filter.Value = jv.Value.Value <string>();
break;
}
}
return(filter);
}
public void AddSuperAdmin()
{
var elasticClient = GetElasticClient();
var termFilter = new TermFilter()
{
Field = ConstAdmin.TYPE,
Value = (short)BillingEnums.USER_TYPE.SUPER_ADMIN
};
try
{
var response = elasticClient.Search <Admin>(a => a
.Index(ElasticMappingConstants.INDEX_NAME)
.Type(ElasticMappingConstants.TYPE_ADMIN)
.Filter(termFilter)
.Take(1));
if (response.Total == 0)
{
var salt = PasswordHash.GenerateSalt();
var admin = new Admin()
{
id = Guid.NewGuid(),
username = AppConstants.SUPER_ADMIN_USER_NAME,
salt = salt,
password = PasswordHash.CreateHash(AppConstants.SUPER_ADMIN_PASSWORD, salt),
type = (int)BillingEnums.USER_TYPE.SUPER_ADMIN,
created_at = DateTime.UtcNow
};
var create = elasticClient.Index <Admin>(admin, i => i
.Index(ElasticMappingConstants.INDEX_NAME)
.Type(ElasticMappingConstants.TYPE_ADMIN));
}
}
catch (Exception e)
{
Console.Error.WriteLine(e.GetBaseException().Message);
}
}
public override void BuildFilter <T>(object query, object options, ref FilterContainer container)
{
var fieldValuesQuery = query as IFieldConditionsQuery;
if (fieldValuesQuery?.FieldConditions == null || fieldValuesQuery.FieldConditions.Count <= 0)
{
return;
}
foreach (var fieldValue in fieldValuesQuery.FieldConditions)
{
switch (fieldValue.Operator)
{
case ComparisonOperator.Equals:
container &= new TermFilter {
Field = fieldValue.Field, Value = fieldValue.Value
};
break;
case ComparisonOperator.NotEquals:
container &= new NotFilter {
Filter = FilterContainer.From(new TermFilter {
Field = fieldValue.Field, Value = fieldValue.Value
})
};
break;
case ComparisonOperator.IsEmpty:
container &= new MissingFilter {
Field = fieldValue.Field
};
break;
case ComparisonOperator.HasValue:
container &= new ExistsFilter {
Field = fieldValue.Field
};
break;
}
}
}
private async Task <bool> ValidateNotExist(Term Term)
{
TermFilter filter = new TermFilter
{
SubjectName = new StringFilter {
Equal = Term.SubjectName
},
SemesterCode = new StringFilter {
Equal = Term.SemesterCode
}
};
int count = await UOW.TermRepository.Count(filter);
if (count > 0)
{
Term.AddError(nameof(TermValidator), nameof(Term), ERROR.TermExisted);
return(false);
}
return(true);
}
private IQueryable <TermDAO> DynamicFilter(IQueryable <TermDAO> query, TermFilter filter)
{
if (filter == null)
{
return(query.Where(q => 1 == 0));
}
//query = query.Where(q => q.Semester.Id, filter.SemesterId);
if (filter.SemesterCode != null)
{
string[] codeData = filter.SemesterCode.Equal.Split("_");
query = query.Where(q => q.Semester.StartYear, new ShortFilter {
Equal = short.Parse(codeData[0])
});
query = query.Where(q => q.Semester.EndYear, new ShortFilter {
Equal = short.Parse(codeData[1])
});
query = query.Where(q => q.Semester.IsFirstHalf == (codeData[2] == "1" ? true : false));
}
if (filter.Id != null)
{
query = query.Where(q => q.Id, filter.Id);
}
if (filter.StudentNumber != null)
{
if (filter.StudentNumber.Equal.HasValue)
{
query = query.Where(q => q.StudentTerms.Select(s => s.Student.StudentNumber == filter.StudentNumber.Equal.Value).Contains(true));
}
}
if (filter.SubjectName != null)
{
query = query.Where(q => q.SubjectName, filter.SubjectName);
}
if (filter.SemesterId != null)
{
query = query.Where(q => q.SemesterId, filter.SemesterId);
}
return(query);
}
public async Task <List <TermDTO> > ListTerm()
{
ExamProgram currentExamProgram = await ExamProgramService.GetCurrentExamProgram();
TermFilter filter = new TermFilter
{
StudentNumber = new IntFilter {
Equal = CurrentContext.StudentNumber
},
SemesterId = new GuidFilter {
Equal = currentExamProgram.SemesterId
}
};
List <Term> res = await TermService.List(filter);
return(res.Select(r => new TermDTO
{
Id = r.Id,
SemesterId = r.SemesterId,
SubjectName = r.SubjectName,
SemesterCode = r.SemesterCode,
ExamPeriods = r.ExamPeriods
.Where(e => e.ExamProgramId.Equals(currentExamProgram.Id))
.Select(e => new ExamPeriodDTO
{
Id = e.Id,
ExamProgramId = e.ExamProgramId,
TermId = e.TermId,
SubjectName = e.SubjectName,
StartHour = e.StartHour,
FinishHour = e.FinishHour,
ExamDate = e.ExamDate.ToString("dd-MM-yyyy"),
ExamProgramName = e.ExamProgramName,
Errors = e.Errors
})
.ToList(),
IsQualified = r.QualifiedStudents.Where(q => q.StudentNumber == CurrentContext.StudentNumber).Any(),
Errors = r.Errors
}).ToList());
}
public override ITypeSearch<FindProduct> ApplyFilter(ITypeSearch<FindProduct> query)
{
if(string.IsNullOrEmpty(FieldName) == false)
{
string fullFieldName = query.Client.GetFullFieldName(FieldName, typeof(double));
switch (FieldOperator)
{
case NumericOperatorSelectionFactory.OperatorNames.GreaterThan:
RangeFilter<double> greaterThanFilter = RangeFilter.Create(fullFieldName, FieldValue, double.MaxValue);
greaterThanFilter.IncludeLower = false;
greaterThanFilter.IncludeUpper = true;
query = query.Filter(greaterThanFilter);
break;
case NumericOperatorSelectionFactory.OperatorNames.LessThan:
RangeFilter<double> lessThanFilter = RangeFilter.Create(fullFieldName, double.MinValue, FieldValue);
lessThanFilter.IncludeLower = false;
lessThanFilter.IncludeUpper = true;
query = query.Filter(lessThanFilter);
break;
default:
case NumericOperatorSelectionFactory.OperatorNames.Equal:
var termFilter = new TermFilter(fullFieldName, FieldValue);
query = query.Filter(termFilter);
break;
}
}
return query;
}
