private QueryBuilder BuildSort(JObject query, string cultureCode)
{
var sort = Select.Sort;
var sortArray = query["Sort"] as JArray;
if (sortArray != null && sortArray.Any())
{
foreach (JObject item in sortArray)
{
string fieldName = item["Field"].ToString();
string fieldOrder = item["Order"].ToString();
sort.Add(FieldConfigUtils.CreateSortRule(_indexConfig, cultureCode, fieldName, fieldOrder == "desc"));
}
}
else
{
sort.Add(new SortRule()
{
Field = "createdondate",
FieldType = FieldTypeEnum.DATETIME,
Descending = true
});
}
return(this);
}
public QueryBuilder BuildSort(string Sorts, string cultureCode)
{
var Sort = Select.Sort;
if (!string.IsNullOrEmpty(Sorts))
{
var sortArray = Sorts.Split(',');
foreach (var item in sortArray)
{
bool reverse = false;
var sortElements = item.Split(' ');
string fieldName = sortElements[0];
if (sortElements.Length > 1 && sortElements[1].ToLower() == "desc")
{
reverse = true;
}
Sort.Add(FieldConfigUtils.CreateSortRule(IndexConfig, cultureCode,
fieldName,
reverse
));
}
}
return(this);
}
public static Select MergeQuery(FieldConfig config, Select select, RestSelect restSelect, string cultureCode)
{
var query = select.Query;
select.PageSize = restSelect.PageSize;
select.PageIndex = restSelect.PageIndex;
if (restSelect.Query != null && restSelect.Query.FilterRules != null)
{
foreach (var rule in restSelect.Query.FilterRules)
{
if (rule.FieldOperator == OperatorEnum.IN)
{
if (rule.MultiValue != null)
{
query.AddRule(FieldConfigUtils.CreateFilterRule(config, cultureCode,
rule.Field,
rule.FieldOperator,
rule.MultiValue.Select(v => new StringRuleValue(v.ToString()))
));
}
}
else if (rule.FieldOperator == OperatorEnum.BETWEEN)
{
// not yet implemented
}
else
{
if (rule.Value != null)
{
query.AddRule(FieldConfigUtils.CreateFilterRule(config, cultureCode,
rule.Field,
rule.FieldOperator,
new StringRuleValue(rule.Value.ToString())
));
}
}
}
}
if (restSelect.Sort != null && restSelect.Sort.Any())
{
select.Sort.Clear();
foreach (var sort in restSelect.Sort)
{
select.Sort.Add(FieldConfigUtils.CreateSortRule(config, cultureCode,
sort.Field,
sort.Descending
));
}
}
return(select);
}
private void BuildQueryStringFilter(NameValueCollection queryString, FilterGroup workFlowFilter)
{
if (queryString != null)
{
foreach (string key in queryString)
{
if (IndexConfig != null && IndexConfig.Fields != null && IndexConfig.Fields.Any(f => f.Key.Equals(key, StringComparison.InvariantCultureIgnoreCase)))
{
var indexConfig = IndexConfig.Fields.Single(f => f.Key.Equals(key, StringComparison.InvariantCultureIgnoreCase));
string val = queryString[key];
workFlowFilter.AddRule(new FilterRule()
{
Field = indexConfig.Key,
Value = new StringRuleValue(val),
FieldOperator = OperatorEnum.EQUAL,
FieldType = FieldConfigUtils.GetFieldType(indexConfig.Value != null ? indexConfig.Value.IndexType : string.Empty)
});
}
}
}
}
public QueryBuilder BuildSort(JObject query, string cultureCode)
{
var Sort = Select.Sort;
var sortArray = query["Sort"] as JArray;
if (sortArray != null && sortArray.Any())
{
foreach (JObject item in sortArray)
{
string fieldName = item["Field"].ToString();
string fieldOrder = item["Order"].ToString();
Sort.Add(FieldConfigUtils.CreateSortRule(IndexConfig, cultureCode, fieldName, fieldOrder == "desc"));
}
}
else
{
string fieldName = "createdondate";
string fieldOrder = "desc";
Sort.Add(FieldConfigUtils.CreateSortRule(IndexConfig, cultureCode, fieldName, fieldOrder == "desc"));
}
return(this);
}
private QueryBuilder BuildFilter(JObject query, bool addWorkflowFilter, int userId, string cultureCode, IList <UserRoleInfo> roles, NameValueCollection queryString = null)
{
var workFlowFilter = Select.Filter;
var vExcludeCurrentItem = query["ExcludeCurrentItem"] as JValue;
bool excludeCurrentItem = false;
if (vExcludeCurrentItem != null && vExcludeCurrentItem.Type == JTokenType.Boolean)
{
excludeCurrentItem = (bool)vExcludeCurrentItem.Value;
}
if (excludeCurrentItem && queryString?["id"] != null)
{
workFlowFilter.AddRule(new FilterRule()
{
Field = "id",
Value = new StringRuleValue(queryString["id"]),
FieldOperator = OperatorEnum.NOT_EQUAL
});
}
var vCurrentUserItems = query["CurrentUserItems"] as JValue;
bool currentUserItems = false;
if (vCurrentUserItems != null && vCurrentUserItems.Type == JTokenType.Boolean)
{
currentUserItems = (bool)vCurrentUserItems.Value;
}
if (currentUserItems)
{
workFlowFilter.AddRule(new FilterRule()
{
Field = "userid",
Value = new StringRuleValue(userId.ToString()),
FieldOperator = OperatorEnum.EQUAL
});
}
var filter = query["Filter"] as JObject;
if (filter != null)
{
foreach (var item in filter.Properties())
{
var fieldConfig = FieldConfigUtils.GetField(IndexConfig, item.Name);
if (item.Value is JValue) // text, int
{
var val = item.Value.ToString();
if (fieldConfig != null && fieldConfig.IndexType == "boolean")
{
bool bval;
if (bool.TryParse(val, out bval))
{
workFlowFilter.AddRule(new FilterRule()
{
Field = item.Name,
FieldType = FieldTypeEnum.BOOLEAN,
Value = new BooleanRuleValue(bval)
});
}
}
else if (fieldConfig != null && fieldConfig.IndexType == "float")
{
float fval;
if (float.TryParse(val, out fval))
{
workFlowFilter.AddRule(new FilterRule()
{
Field = item.Name,
FieldType = FieldTypeEnum.FLOAT,
Value = new FloatRuleValue(fval)
});
}
}
else if (!string.IsNullOrEmpty(val))
{
workFlowFilter.AddRule(FieldConfigUtils.CreateFilterRule(IndexConfig, cultureCode,
item.Name,
OperatorEnum.START_WITH,
new StringRuleValue(val)
));
}
}
else if (item.Value is JArray) // enum
{
var arr = (JArray)item.Value;
if (arr.Children().Any())
{
var arrGroup = new FilterGroup();
foreach (var arrItem in arr.Children())
{
if (arrItem is JValue)
{
var val = (JValue)arrItem;
arrGroup.AddRule(FieldConfigUtils.CreateFilterRule(IndexConfig, cultureCode,
item.Name,
OperatorEnum.EQUAL,
new StringRuleValue(val.ToString())
));
}
}
workFlowFilter.FilterGroups.Add(arrGroup);
}
else if (queryString?[item.Name] != null)
{
workFlowFilter.AddRule(FieldConfigUtils.CreateFilterRule(IndexConfig, cultureCode,
item.Name,
OperatorEnum.EQUAL,
new StringRuleValue(queryString[item.Name])
));
}
}
else if (item.Value is JObject) // range
{
var valObj = (JObject)item.Value;
var startDays = valObj["StartDays"] as JValue;
var endDays = valObj["EndDays"] as JValue;
if ((startDays?.Value != null) || (endDays?.Value != null))
{
var startDate = DateTime.MinValue;
var endDate = DateTime.MaxValue;
var useTime = false;
try
{
useTime = (bool)(valObj["UseTime"] as JValue).Value;
}
catch (Exception)
{
}
DateTime currentDateTime = useTime ? DateTime.Now : DateTime.Today;
try
{
startDate = currentDateTime.AddDays(-(long)startDays.Value);
}
catch (Exception)
{
}
try
{
endDate = currentDateTime.AddDays((long)endDays.Value);
}
catch (Exception)
{
}
workFlowFilter.AddRule(new FilterRule()
{
Field = item.Name,
FieldType = FieldTypeEnum.DATETIME,
LowerValue = new DateTimeRuleValue(startDate),
UpperValue = new DateTimeRuleValue(endDate),
FieldOperator = OperatorEnum.BETWEEN
});
}
}
}
}
BuildQueryStringFilter(queryString, workFlowFilter);
if (addWorkflowFilter)
{
AddWorkflowFilter(workFlowFilter);
AddRolesFilter(workFlowFilter, roles);
}
//Filter = Filter.FilterRules.Any() || Filter.FilterGroups.Any() > 0 ? q : null;
return(this);
}
public static Select MergeJpListQuery(FieldConfig config, Select select, List <StatusDTO> statuses, string cultureCode)
{
var query = select.Query;
foreach (StatusDTO status in statuses)
{
switch (status.action)
{
case "paging":
{
int number;
// string value (it could be number or "all")
int.TryParse(status.data.number, out number);
select.PageSize = number;
select.PageIndex = status.data.currentPage;
break;
}
case "filter":
{
if (status.data != null)
{
if (status.type == "textbox" && !string.IsNullOrEmpty(status.name) && !string.IsNullOrEmpty(status.data.value))
{
var names = status.name.Split(',');
if (names.Length == 1)
{
query.AddRule(FieldConfigUtils.CreateFilterRule(config, cultureCode,
status.name,
OperatorEnum.START_WITH,
new StringRuleValue(status.data.value)
));
}
else
{
var group = new FilterGroup()
{
Condition = ConditionEnum.OR
};
foreach (var n in names)
{
group.AddRule(FieldConfigUtils.CreateFilterRule(config, cultureCode,
n,
OperatorEnum.START_WITH,
new StringRuleValue(status.data.value)
));
}
query.FilterGroups.Add(group);
}
}
else if ((status.type == "checkbox-group-filter" || status.type == "button-filter-group" || status.type == "combined") && !string.IsNullOrEmpty(status.name))
{
if (status.data.filterType == "pathGroup" && status.data != null && status.data.pathGroup != null && status.data.pathGroup.Count > 0 && status.data.pathGroup[0] != "*")
{
query.AddRule(FieldConfigUtils.CreateFilterRule(config, cultureCode,
status.name,
OperatorEnum.IN,
status.data.pathGroup.Select(s => new StringRuleValue(s))
));
}
}
else if ((status.type == "filter-select" || status.type == "filter-drop-down") && !string.IsNullOrEmpty(status.name))
{
if (status.data.filterType == "path" && !string.IsNullOrEmpty(status.data.path) && (status.data.path != "*"))
{
query.AddRule(FieldConfigUtils.CreateFilterRule(config, cultureCode,
status.name,
OperatorEnum.EQUAL,
new StringRuleValue(status.data.path)
));
}
}
else if (status.type == "autocomplete" && !string.IsNullOrEmpty(status.data.path) && !string.IsNullOrEmpty(status.data.value))
{
var names = status.data.path.Split(',');
if (names.Length == 1)
{
query.AddRule(FieldConfigUtils.CreateFilterRule(config, cultureCode,
status.data.path,
OperatorEnum.START_WITH,
new StringRuleValue(status.data.value)
));
}
else
{
var group = new FilterGroup()
{
Condition = ConditionEnum.OR
};
foreach (var n in names)
{
group.AddRule(FieldConfigUtils.CreateFilterRule(config, cultureCode,
n,
OperatorEnum.START_WITH,
new StringRuleValue(status.data.value)
));
}
query.FilterGroups.Add(group);
}
}
}
break;
}
case "sort":
{
select.Sort.Clear();
select.Sort.Add(FieldConfigUtils.CreateSortRule(config, cultureCode,
status.data.path,
status.data.order == "desc"
));
break;
}
}
}
return(select);
}
public static Select MergeQuery(FieldConfig config, Select select, RestSelect restSelect, string cultureCode)
{
var query = select.Query;
select.PageSize = restSelect.PageSize;
select.PageIndex = restSelect.PageIndex;
if (restSelect.Query != null && restSelect.Query.FilterRules != null)
{
foreach (var rule in restSelect.Query.FilterRules)
{
if (rule.FieldOperator == OperatorEnum.IN)
{
if (rule.MultiValue != null)
{
query.AddRule(FieldConfigUtils.CreateFilterRule(config, cultureCode,
rule.Field,
rule.FieldOperator,
rule.MultiValue.Select(v => new StringRuleValue(v.ToString()))
));
}
}
else if (rule.FieldOperator == OperatorEnum.BETWEEN)
{
// not yet implemented
}
else
{
if (rule.Value != null)
{
RuleValue val;
if (rule.Value.Type == Newtonsoft.Json.Linq.JTokenType.Boolean)
{
val = new BooleanRuleValue((bool)rule.Value.Value);
}
else if (rule.Value.Type == Newtonsoft.Json.Linq.JTokenType.Integer)
{
val = new IntegerRuleValue((int)rule.Value.Value);
}
else if (rule.Value.Type == Newtonsoft.Json.Linq.JTokenType.Float)
{
val = new FloatRuleValue((float)rule.Value.Value);
}
else
{
val = new StringRuleValue(rule.Value.ToString());
}
query.AddRule(FieldConfigUtils.CreateFilterRule(config, cultureCode,
rule.Field,
rule.FieldOperator,
val
));
}
}
}
}
if (restSelect.Sort != null && restSelect.Sort.Any())
{
select.Sort.Clear();
foreach (var sort in restSelect.Sort)
{
select.Sort.Add(FieldConfigUtils.CreateSortRule(config, cultureCode,
sort.Field,
sort.Descending
));
}
}
return(select);
}
