private MultiFacetRequest BuildRequest(int maxResults)
{
var request = new MultiFacetRequest
{
Query = Query,
Sort = SortFields.ToList(),
MaxResults = maxResults,
Config = FacetSearcherConfiguration.Default(),
Facets = new List <FacetFieldInfo>()
};
foreach (var field in Fields)
{
if (field.MinHits > 0)
{
request.Config.MinimumCountInTotalDatasetForFacet = field.MinHits;
}
var fieldInfo = new FacetFieldInfo
{
FieldName = field.Name,
MaxToFetchExcludingSelections = field.MaxCount
};
if (field.Values != null)
{
fieldInfo.Selections = field.Values.ToList();
}
request.Facets.Add(fieldInfo);
}
return(request);
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Makes the specified field the first, or primary, field on which to sort.
/// </summary>
/// ------------------------------------------------------------------------------------
public bool SetPrimarySortField(PaField field, bool changeDirection, bool ascending)
{
if (field == null)
{
return(ascending);
}
var sortInfo = SortFields.SingleOrDefault(si => si.Field.Name == field.Name);
int index = (sortInfo == null ? -1 : SortFields.IndexOf(sortInfo));
// If the sort information list already contains an item for the specified field,
// we need to remove it before reinserting it at the beginning of the list.
if (index > -1)
{
if (changeDirection)
{
ascending = SortFields[index].Ascending;
}
SortFields.RemoveAt(index);
}
if (changeDirection)
{
ascending = !ascending;
}
// Now insert an item at the beginning of the list since the specified field
// has now become the first (i.e. primary) field on which to sort.
SortFields.Insert(0, new SortField(field, ascending));
return(ascending);
}
protected void SortByField()
{
if (SortFields != null && SortFields.Any())
{
Operations = OrderByFields(SortFields);
}
}
/// <summary>
/// Add a field into the sorting of result
/// </summary>
/// <returns>FindRequest with new sorting option</returns>
/// <param name="field">The sort field</param>
/// <param name="ascending">True if direction of sort is Asceding use false for Descending(Default is True)</param>
public FindRequest <T> Sort(Expression <Func <T, object> > field, bool ascending = true)
{
var fieldName = Metadata.GetMemberInfo(field).Member.Name;
SortFields.Add(new Sorting(fieldName, ascending));
return(this);
}
public override ISearchResults Execute(int maxResults = 500)
{
_request.BrowseRequest.Count = maxResults;
_request.BrowseRequest.Sort = SortFields.ToArray();
return(new BoboFacetSearchResults(_searchContext, _request));
}
public void AddSortField(SortField sortField)
{
if (string.IsNullOrWhiteSpace(sortField.Label))
{
sortField.Label = TextService.Title(sortField.Name);
}
SortFields.Add(sortField);
}
private string GetUniqueCode()
{
//Return code specific for this list for assembly cache
return(string.Format("f[{0}]s[{1}]",
ShouldFilter() ? FilterBy : string.Empty,
ShouldSort() ? string.Join(",", SortFields.ToArray()) : string.Empty
).ToLowerInvariant());
}
internal static async Task <VehicleOverviews> MapToVehicleOverviews(
VehicleOverviewsRequest request,
IQueryable <VehicleEntity> vehicles,
IQueryable <MakerEntity> makers,
IQueryable <ModelEntity> models,
IQueryable <OwnerEntity> owners)
{
// Build SQL query
var query1 = from v in vehicles.GetByMakers(request.Makers)
.GetByModels(request.Models)
.GetByFeatures(request.Features)
.GetByContactName(request.ContactName)
join m in models on v.ModelId equals m.Id
join mk in makers on m.MakerId equals mk.Id
join o in owners on v.OwnerId equals o.Id
select new
{
VehicleId = v.Id,
Maker = mk,
Model = m,
Owner = o
};
var query = from q1 in query1
select new VehicleOverviewQuery
{
VehicleId = q1.VehicleId,
Maker = q1.Maker,
Model = q1.Model,
Owner = q1.Owner,
RecordsCount = query1.Count()
};
var sortBy = new SortFields <VehicleOverviewQuery>
{
{ "maker", e => e.Maker.Name },
{ "model", e => e.Model.Name },
{ "contact", e => e.Owner.LastName, e => e.Owner.FirstName }
};
query = query
.SortBy(request, sortBy)
.GetPage(request);
// Run SQL query
var entities = await query.ToArrayAsync();
// Map entities to models
var overviews = entities.Select(e => new VehicleOverview(e.VehicleId,
e.Maker.Name,
e.Model.Name,
$"{e.Owner.FirstName} {e.Owner.LastName}"));
return(new VehicleOverviews(
request,
entities.Any() ? entities.First().RecordsCount : 0,
overviews));
}
public string Build(SortFields sortFields = SortFields.ByInsertionOrder)
{
var sb = new StringBuilder();
Sort(sortFields);
ExportHeader(sb);
ExportRows(sb);
return(sb.ToString());
}
private static void ProcessSortFields(SortFields sfs, XmlWriter xmlw)
{
xmlw.WriteStartElement("SortFields");
xmlw.WriteAttributeString("Count", sfs.Count.ToStringSafe());
foreach (SortField sf in sfs)
{
ProcessSortField(sf, xmlw);
}
xmlw.WriteEndElement();
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Returns a deep copy of the sort options.
/// </summary>
/// ------------------------------------------------------------------------------------
public SortOptions Copy()
{
var copy = new SortOptions(false, _project);
copy.SortType = SortType;
copy.SaveManuallySetSortOptions = SaveManuallySetSortOptions;
copy.AdvancedEnabled = AdvancedEnabled;
Array.Copy(AdvSortOrder, copy.AdvSortOrder, AdvSortOrder.Length);
Array.Copy(AdvRlOptions, copy.AdvRlOptions, AdvRlOptions.Length);
copy.SortFields = SortFields.Select(sf => sf.Copy()).ToList();
return(copy);
}
public SearchDescriptor <T> GetSearchDescriptor()
{
var res = new SearchDescriptor <T>()
.Index(Indices)
.Skip(Skip ?? 0)
.Take(Take ?? 10)
.Aggregations(a => BucketFields.GetBucketAggreagationDescriptor <T>())
.Sort(x => SortFields.GetSortDescriptor <T>())
.Query(x => x.QueryString(q => q.Query(Text)));
return(res);
}
public SearchDescriptor <T> GetSearchDescriptor()
{
var s = new SearchDescriptor <T>()
.Index(Indices)
.Skip(Skip ?? 0)
.Take(Take ?? 10)
.Aggregations(a => BucketFields.GetBucketAggreagationDescriptor <T>())
.Query(q => FilterFields.GetQueryDesctiptor <T>())
.Source(t => ReturnFields.GetSourceFilterDescriptor <T>())
.Sort(s => SortFields.GetSortDescriptor <T>());
return(s);
}
private void Sort(SortFields sortFields)
{
switch (sortFields)
{
case SortFields.ByName:
_fields.Sort();
break;
case SortFields.ByNameLeaveFirst:
var first = _fields[0];
_fields.RemoveAt(0);
_fields.Sort();
_fields.Insert(0, first);
break;
}
}
/// <summary>
/// OrderBy extension
/// </summary>
/// <typeparam name="T">Entity type</typeparam>
/// <param name="source">Source collection</param>
/// <param name="sortField">Sorting field by</param>
/// <param name="orderRule">Order rule</param>
/// <returns>Sorted iqueryable</returns>
public static IQueryable <T> OrderBy <T>(this IQueryable <T> source, SortFields sortField, OrderRule orderRule)
{
var type = typeof(T);
var property = type.GetProperty(sortField.ToString());
var parameter = Expression.Parameter(type, "p");
var propertyAccess = Expression.MakeMemberAccess(parameter, property);
var orderByExp = Expression.Lambda(propertyAccess, parameter);
var resultExp = Expression.Call(
typeof(Queryable),
orderRule == OrderRule.Asc ? "OrderBy" : "OrderByDescending",
new[] { type, property.PropertyType },
source.Expression,
Expression.Quote(orderByExp));
return(source.Provider.CreateQuery <T>(resultExp));
}
public static GetLoanRequest MapSsnToGetRequest(string ssn, int maxEntities)
{
_log.Debug("START MapSsnToGetRequest");
GetLoanRequest request = new GetLoanRequest();
CriteriaLoan_Ssn c = new CriteriaLoan_Ssn();
c.MaxEntities = maxEntities;
c.CriterionSSN = new ASA.Web.Services.LoanService.Proxy.LoanManagement.CriterionSSNType();
c.CriterionSSN.SSN = ssn;
c.CriterionSSN.LogicalOperator = ASA.Web.Services.LoanService.Proxy.LoanManagement.LogicalOperatorType.AND;
c.CriterionSSN.RelationalOperator = ASA.Web.Services.LoanService.Proxy.LoanManagement.RelationalOperatorType.EQUALS;
c.CriterionRoleId = new ASA.Web.Services.LoanService.Proxy.LoanManagement.CriterionRoleIdType();
c.CriterionRoleId.RoleId = "BORR";
c.CriterionRoleId.LogicalOperator = ASA.Web.Services.LoanService.Proxy.LoanManagement.LogicalOperatorType.AND;
c.CriterionRoleId.RelationalOperator = ASA.Web.Services.LoanService.Proxy.LoanManagement.RelationalOperatorType.EQUALS;
c.CriterionIsArchived = new ASA.Web.Services.LoanService.Proxy.LoanManagement.CriterionIsArchivedType();
c.CriterionIsArchived.IsArchived = ASA.Web.Services.LoanService.Proxy.LoanManagement.YNFlagType.N;
c.CriterionIsArchived.LogicalOperator = ASA.Web.Services.LoanService.Proxy.LoanManagement.LogicalOperatorType.AND;
c.CriterionIsArchived.RelationalOperator = ASA.Web.Services.LoanService.Proxy.LoanManagement.RelationalOperatorType.EQUALS;
c.CriterionInputSourceId = new ASA.Web.Services.LoanService.Proxy.LoanManagement.CriterionInputSourceIDType();
c.CriterionInputSourceId.InputSourceId = "DER";
c.CriterionInputSourceId.LogicalOperator = ASA.Web.Services.LoanService.Proxy.LoanManagement.LogicalOperatorType.AND;
c.CriterionInputSourceId.RelationalOperator = ASA.Web.Services.LoanService.Proxy.LoanManagement.RelationalOperatorType.CONTAINS;
c.ListReturnTypes = new ASA.Web.Services.LoanService.Proxy.LoanManagement.ReturnListType();
c.ListReturnTypes.LoanTier2Type = ASA.Web.Services.LoanService.Proxy.LoanManagement.YNFlagType.Y;
c.ListReturnTypes.LoanTier2OrganizationArray = ASA.Web.Services.LoanService.Proxy.LoanManagement.YNFlagType.Y;
c.ListReturnTypes.LoanTier2PersonArray = ASA.Web.Services.LoanService.Proxy.LoanManagement.YNFlagType.Y;
//set sort values. This will help (but not gaurantee) that the newer IsArchived=N, InputSourceId %DER%
// are more likely to be in the list of loans returned.
SortFields sortFields = new SortFields();
sortFields.IsArchived = SortOperatorType.DESC;
sortFields.InputSourceId = SortOperatorType.ASC;
c.SortFields = sortFields;
request.Criteria = c as LoanServiceCriteriaType;
_log.Debug("END MapSsnToGetRequest");
return(request);
}
public void Sort(SortFields sortField, bool isAscending)
{
switch (sortField)
{
case SortFields.Name:
base.Sort(new NameComparer());
break;
case SortFields.TTL:
base.Sort(new TTLComparer());
break;
}
if (!isAscending)
{
base.Reverse();
}
}
///// ------------------------------------------------------------------------------------
///// <summary>
///// Compares the contents of this SortOptions object with the one specified.
///// TODO: Write some tests for this method. It could be used to fix PA-830.
///// </summary>
///// ------------------------------------------------------------------------------------
//public bool AreEqual(SortOptions otherOptions)
//{
// if (otherOptions == null)
// return false;
// if (m_sortType != otherOptions.m_sortType ||
// m_advancedEnabled != otherOptions.m_advancedEnabled ||
// m_saveManuallySetSortOptions != otherOptions.m_saveManuallySetSortOptions)
// {
// return false;
// }
// for (int i = 0; i < m_advSortOptions.Length; i++)
// {
// if (m_advSortOptions[i] != otherOptions.m_advSortOptions[i])
// return false;
// }
// for (int i = 0; i < m_advRlOptions.Length; i++)
// {
// if (m_advRlOptions[i] != otherOptions.m_advRlOptions[i])
// return false;
// }
// if (m_sortInfoList == null && otherOptions.m_sortInfoList != null ||
// m_sortInfoList != null && otherOptions.m_sortInfoList == null ||
// m_sortInfoList.Count != otherOptions.m_sortInfoList.Count)
// {
// return false;
// }
// for (int i = 0; i < m_sortInfoList.Count; i++)
// {
// if (m_sortInfoList[i].ascending != otherOptions.m_sortInfoList[i].ascending ||
// m_sortInfoList[i].FieldInfo.FieldName !=
// otherOptions.m_sortInfoList[i].FieldInfo.FieldName)
// {
// return false;
// }
// }
// return true;
//}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Deserializing a project brings in only the field names for the sort options's
/// SortFields property. We actually want each SortFields entry to contain a pointer
/// to a project's field. This will make sure each one points to a real PaField.
/// </summary>
/// ------------------------------------------------------------------------------------
public void PostDeserializeInitialization(PaProject project)
{
_project = project;
foreach (var sf in SortFields)
{
sf.Field = project.Fields.SingleOrDefault(f => f.Name == sf.PaFieldName);
sf.PaFieldName = null;
}
// Toss out any fields that couldn't be mapped, although that should probably never happen.
SortFields = SortFields.Where(sf => sf.Field != null).ToList();
// We have to have at least one sort field.
if (SortFields.Count == 0)
{
SetPrimarySortField(project.Fields.SingleOrDefault(f =>
f.Type == FieldType.Phonetic), false, true);
}
}
SortEdgeTable
(
ListObject oEdgeTable,
Range oRangeToSortOn
)
{
Debug.Assert(oEdgeTable != null);
Debug.Assert(oRangeToSortOn != null);
AssertValid();
Sort oSort = oEdgeTable.Sort;
SortFields oSortFields = oSort.SortFields;
oSortFields.Clear();
oSortFields.Add(oRangeToSortOn, XlSortOn.xlSortOnValues,
XlSortOrder.xlAscending, Missing.Value,
XlSortDataOption.xlSortNormal);
oSort.Apply();
oSortFields.Clear();
}
/// <summary>
/// Add sort field. Use + prefix for asc sorting, or use - prefix for desc sorting.
/// </summary>
public IndexQuery AddOrderBy(string field)
{
var reverse = false;
if (field[0] == '+' || field[0] == '-')
{
reverse = field[0] == '-';
field = field.Substring(1);
}
var sortType = Lucene.Net.Search.SortField.STRING;
var property = ModelType.GetProperty(field, System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Instance);
if (property != null)
{
sortType = LuceneUtility.GetSortType(property.PropertyType);
}
SortFields.Add(new SortField(field, sortType, reverse));
return(this);
}
private BoboFacetRequest BuildRequest(int maxResults)
{
var request = new BoboFacetRequest
{
BrowseRequest = new BrowseRequest
{
Query = Query,
Sort = SortFields.ToArray(),
Count = maxResults,
FetchStoredFields = true
},
FacetHandlers = new List <IFacetHandler>()
};
foreach (var field in Fields)
{
var spec = new FacetSpec()
{
MinHitCount = field.MinHits,
MaxCount = field.MaxCount
};
request.BrowseRequest.SetFacetSpec(field.Name, spec);
if (field.Values != null)
{
request.BrowseRequest.AddSelection(new BrowseSelection(field.Name)
{
Values = field.Values
});
}
request.FacetHandlers.Add(new MultiValueFacetHandler(field.Name));
}
return(request);
}
private bool ShouldSort()
{
return(SortFields != null && SortFields.Any());
}
/// <summary>
/// Sorts the contents based on the sort field specified
/// </summary>
/// <param name="bAscending">ascending or descending</param>
/// <param name="sortField">one of the sort fields above</param>
/// <returns>true on success</returns>
public bool SortContents(bool bAscending, SortFields sortField)
{
return(MAPISortContents(pMAPI, bAscending, (int)sortField));
}
public async Task <ActionResult <HdTicketsOutputDto> > GetHdTickets(
[FromQuery] string assignee,
string software,
string referredTo,
string department,
string location,
string excludedStatuses,
string sort,
int page = 1,
int perPage = 20)
{
IQueryable <HdTicketsDto> query = _context.HdTicket
.Where(t => t.HdQueueId == 1)
.Select(t => new HdTicketsDto
{
Ticket = t.Id,
Title = t.Title,
Priority = t.Priority.Name,
Owner = t.Owner.FullName,
Submitter = t.Submitter.FullName,
Asset = t.Asset.Name,
Status = t.Status.Name,
ReferredTo = t.CustomFieldValue5,
UserName = t.Owner.UserName,
Dept = t.CustomFieldValue1,
Location = t.CustomFieldValue2,
PriOrd = t.Priority.Ordinal,
StatOrd = t.Status.Ordinal,
Created = t.Created
});
if (excludedStatuses != null)
{
string[] excludedList = excludedStatuses.Split(',');
query = excludedList
.Aggregate(query, (current, status) => current.Where(t => t.Status != status));
}
if (assignee != null)
{
query = query.Where(t => t.UserName == assignee);
}
if (software != null)
{
query = query.Where(t => t.Asset == software);
}
if (referredTo != null)
{
query = query.Where(t => t.ReferredTo == referredTo);
}
if (department != null)
{
query = query.Where(t => t.Dept == department);
}
if (location != null)
{
query = query.Where(t => t.Location == location);
}
IOrderedQueryable <HdTicketsDto> orderedQuery = query.OrderBy(t => 0);
var sortFields = new SortFields(sort);
orderedQuery = sortFields.Fields?.Aggregate(orderedQuery, (current, sortField) =>
sortField.Field switch
{
"ticket" => (sortField.SortDesc
? current.ThenByDescending(t => t.Ticket)
: current.ThenBy(t => t.Ticket)),
"title" => (sortField.SortDesc
? current.ThenByDescending(t => t.Title)
: current.ThenBy(t => t.Title)),
"priority" => (sortField.SortDesc
? current.ThenByDescending(t => t.PriOrd)
: current.ThenBy(t => t.PriOrd)),
"status" => (sortField.SortDesc
? current.ThenByDescending(t => t.StatOrd)
: current.ThenBy(t => t.StatOrd)),
"owner" => (sortField.SortDesc
? current.ThenByDescending(t => t.Owner)
: current.ThenBy(t => t.Owner)),
"submitter" => (sortField.SortDesc
? current.ThenByDescending(t => t.Submitter)
: current.ThenBy(t => t.Submitter)),
"asset" => (sortField.SortDesc
? current.ThenByDescending(t => t.Asset)
: current.ThenBy(t => t.Asset)),
"referredto" => (sortField.SortDesc
? current.ThenByDescending(t => t.ReferredTo)
: current.ThenBy(t => t.ReferredTo)),
"dept" => (sortField.SortDesc
? current.ThenByDescending(t => t.Dept)
: current.ThenBy(t => t.Dept)),
"location" => (sortField.SortDesc
? current.ThenByDescending(t => t.Location)
: current.ThenBy(t => t.Location)),
"created" => (sortField.SortDesc
? current.ThenByDescending(t => t.Created)
: current.ThenBy(t => t.Created)),
_ => current
}
public void AddField(SortField <T> field)
{
SortFields.Add(field);
}
/// <summary>
/// Sorts the contents based on the sort field specified
/// </summary>
/// <param name="bAscending">ascending or descending</param>
/// <param name="sortField">one of the sort fields above</param>
/// <returns>true on success</returns>
public bool SortContents(bool bAscending, SortFields sortField)
{
return MAPISortContents(pMAPI, bAscending, (int)sortField);
}
/// <summary>
/// Internal operation for adding the ordered results
/// </summary>
/// <param name="descending">if set to <c>true</c> [descending].</param>
/// <param name="fields">The field names.</param>
/// <returns>A new <see cref="IBooleanOperation"/> with the clause appended</returns>
private LuceneBooleanOperation OrderByInternal(bool descending, params SortableField[] fields)
{
if (fields == null)
{
throw new ArgumentNullException(nameof(fields));
}
foreach (var f in fields)
{
var fieldName = f.FieldName;
var defaultSort = SortField.STRING;
switch (f.SortType)
{
case SortType.Score:
defaultSort = SortField.SCORE;
break;
case SortType.DocumentOrder:
defaultSort = SortField.DOC;
break;
case SortType.String:
defaultSort = SortField.STRING;
break;
case SortType.Int:
defaultSort = SortField.INT;
break;
case SortType.Float:
defaultSort = SortField.FLOAT;
break;
case SortType.Long:
defaultSort = SortField.LONG;
break;
case SortType.Double:
defaultSort = SortField.DOUBLE;
break;
case SortType.Short:
defaultSort = SortField.SHORT;
break;
case SortType.Byte:
defaultSort = SortField.BYTE;
break;
default:
throw new ArgumentOutOfRangeException();
}
//get the sortable field name if this field type has one
var valType = _searchContext.GetFieldValueType(fieldName);
if (valType?.SortableFieldName != null)
{
fieldName = valType.SortableFieldName;
}
SortFields.Add(new SortField(fieldName, defaultSort, descending));
}
return(new LuceneBooleanOperation(this));
}
public FindRequest <T> Sort(string fieldName, bool ascending = true)
{
SortFields.Add(new Sorting(fieldName, ascending));
return(this);
}
public bool HasSortFields()
{
return(SortFields != null && SortFields.Any());
}
internal static async Task <ScheduleOverviews> MapToScheduleOverviews(
ScheduleOverviewsRequest request,
IQueryable <ScheduleEntity> schedules,
IQueryable <CompanyEntity> companies,
IQueryable <WellEntity> wells)
{
// Build SQL query
var query1 = from s in schedules.GetByRegions(request.Regions)
.GetByOperators(request.Operators)
.GetByStartNextDays(request.StartNextDays)
join c in companies on s.CompanyId equals c.Id
join w in wells on s.WellId equals w.Id
select new
{
Schedule = s,
Company = c,
Well = w
};
var query = from q1 in query1
select new ScheduleOverviewQuery
{
Schedule = q1.Schedule,
Company = q1.Company,
Well = q1.Well
};
var sortBy = new SortFields <ScheduleOverviewQuery>
{
{ "wellName", e => e.Well.Name },
{ "operator", e => e.Company.Name },
{ "fracStartDate", e => e.Schedule.FracStartDate }
};
query = query
.SortBy(request, sortBy)
.GetPage(request);
// Run SQL query
var entities = await query.ToArrayAsync();
var totalCount = await query1.CountAsync();
// Map entities to models
var overviews = entities.Select(e => new ScheduleOverview(
e.Schedule.Id,
e.Well.Name,
e.Company.Name,
e.Schedule.FracStartDate,
e.Schedule.FracEndDate,
(e.Schedule.FracEndDate - e.Schedule.FracStartDate).Days,
e.Well.Api,
e.Well.SurfaceLat,
e.Well.SurfaceLong,
e.Well.BottomholeLat,
e.Well.BottomholeLong,
e.Well.Tvd,
e.Schedule.FracStartDate.GetStartInDays(),
e.Schedule.FracStartDate.GetScheduleStatus()));
var os = overviews as ScheduleOverview[] ?? overviews.ToArray();
var summary = new ScheduleSummary(
os.Count(o => o.Status == ScheduleStatus.Operating),
os.Count(o => o.Status == ScheduleStatus.Next7Days),
os.Count(o => o.Status == ScheduleStatus.Next830Days),
os.Count(o => o.Status == ScheduleStatus.Next3160Days),
os.Count(o => o.Status == ScheduleStatus.Next60PlusDays));
return(new ScheduleOverviews(
request,
totalCount,
os,
summary));
}
/// <summary>
/// Sorts the contents based on the sort field specified
/// </summary>
/// <param name="bAscending">ascending or descending</param>
/// <param name="sortField">one of the sort fields defined in NetMAPI</param>
/// <returns>true on success</returns>
public bool SortContents(bool bAscending, SortFields sortField)
{
return FolderSortContents(pObject, bAscending, (int)sortField);
}
private ListFilter <T> Compile()
{
var uniqueCode = GetUniqueCode();
ListFilter <T> resultFilter;
if (!FiltersCache.TryGetValue(uniqueCode, out resultFilter))
{
var includeAssemblies = new HashSet <string>();
var provider = new CSharpCodeProvider(new Dictionary <string, string>()
{
{ "CompilerVersion", "v3.5" }
});
var name = "Filter";
if (FilterBy != null)
{
name += "_" + Regex.Replace(FilterBy, @"\W", "");
}
if (SortFields != null)
{
name += "_Sort_" + Regex.Replace(SortFields.Aggregate((y, x) => y), @"\W", "");
}
var typeName = provider.CreateValidIdentifier(name);
var targetTypeName = typeof(T).FullName.Replace('+', '.');
var code = new StringBuilder();
code.AppendLine("using System;");
code.AppendLine("using System.Collections;");
code.AppendLine("using System.Collections.Generic;");
code.AppendLine("using System.Linq;");
code.AppendLine("using ASC.Api.Collections;");
code.AppendLine("using System.Globalization;");
code.AppendFormat("public class {1} : ListFilter<{0}> {{\r\n", targetTypeName, typeName);
code.AppendFormat(
" public override IEnumerable<{0}> FilterList(IEnumerable<{0}> items, bool sortDescending, FilterOperation operation, string[] filterValues){{\r\n",
targetTypeName);
//Do a needed operations
//TODO: Do a null checks!
if (ShouldFilter())
{
try
{
var filters = FilterBy.Split(',');
var filterChecks = new List <string>();
foreach (var filter in filters)
{
var propInfo = GetPropertyInfo(filter).Where(x => x != null).ToList();
foreach (var propertyInfo in propInfo)
{
includeAssemblies.Add(propertyInfo.PropertyType.Assembly.Location);
}
var byProperty = GetPropertyPath(propInfo);
var nullCheck = GetNullCheck("item", propInfo);
filterChecks.Add(string.Format("({1}Satisfy(operation, filterValues, item.{0}{2}))",
byProperty,
string.IsNullOrEmpty(nullCheck) ? "" : (nullCheck + " && "),
GetPropertyToString(propInfo.Last())));
}
code.AppendFormat(
"items = items.Where(item =>{0});\r\n", string.Join(" || ", filterChecks.ToArray()));
}
catch (Exception)
{
}
}
if (ShouldSort())
{
var propInfo = SortFields.Select(x => GetPropertyInfo(x)).Where(x => x != null).ToList();
//Add where
if (propInfo.Any())
{
foreach (var info in propInfo)
{
foreach (var propertyInfo in info)
{
includeAssemblies.Add(propertyInfo.PropertyType.Assembly.Location);
}
var nullCheck = GetNullCheck("item", info);
if (!string.IsNullOrEmpty(nullCheck))
{
code.AppendFormat("items=items.Where(item=>{0});", nullCheck);
code.AppendLine();
}
}
var byProperties = propInfo.Select(x => GetPropertyPath(x)).ToList();
code.AppendLine("items = sortDescending");
code.AppendFormat("?items.OrderByDescending(item => item.{0})", byProperties.First());
foreach (var byProperty in byProperties.Skip(1))
{
code.AppendFormat(".ThenByDescending(item => item.{0})", byProperty);
}
code.AppendFormat(": items.OrderBy(item => item.{0})", byProperties.First());
foreach (var byProperty in byProperties.Skip(1))
{
code.AppendFormat(".ThenBy(item => item.{0})", byProperty);
}
code.AppendLine(";");
}
}
code.AppendFormat("return items;\r\n");
code.AppendLine("} }");
var assemblyName = "filter" + Guid.NewGuid().ToString("N");
var cp = new CompilerParameters
{
GenerateExecutable = false,
OutputAssembly = assemblyName,
GenerateInMemory = true,
TreatWarningsAsErrors = false,
CompilerOptions = "/optimize /t:library",
IncludeDebugInformation = false,
};
cp.ReferencedAssemblies.Add("mscorlib.dll");
cp.ReferencedAssemblies.Add("system.dll");
cp.ReferencedAssemblies.Add("System.Core.dll");
cp.ReferencedAssemblies.Add(GetType().Assembly.Location);
cp.ReferencedAssemblies.Add(typeof(T).Assembly.Location);
foreach (var includeAssembly in includeAssemblies)
{
cp.ReferencedAssemblies.Add(includeAssembly);
}
var cr = provider.CompileAssemblyFromSource(cp, code.ToString());
if (!cr.Errors.HasErrors)
{
var assembly = cr.CompiledAssembly;
var evaluatorType = assembly.GetType(typeName);
var evaluator = Activator.CreateInstance(evaluatorType);
resultFilter = evaluator as ListFilter <T>;
}
//Add anyway!!!
FiltersCache.Add(uniqueCode, resultFilter);
}
return(resultFilter);
}
