public QueryDefinition GenerateQuery()
{
var query = new QueryDefinition(RecordType);
query.Distinct = true;
if (IsQuickFind)
{
query.IsQuickFind = true;
query.QuickFindText = QuickFindText;
if (!string.IsNullOrWhiteSpace(QuickFindText))
{
var quickFindFields = RecordService.GetStringQuickfindFields(RecordType);
query.RootFilter.ConditionOperator = FilterOperator.Or;
query.RootFilter.Conditions.AddRange(quickFindFields.Select(f => new Condition(f, ConditionType.BeginsWith, QuickFindText)));
}
}
else
{
query.RootFilter = FilterConditions.GetAsFilter();
query.Joins = Joins.GetAsJoins().ToList();
}
var view = DynamicGridViewModel.RecordService.GetView(DynamicGridViewModel.RecordType, DynamicGridViewModel.ViewType);
query.Sorts = view.Sorts.ToList();
return(query);
}
public void MergeFrom(C2S other)
{
if (other == null)
{
return;
}
if (other.header_ != null)
{
if (header_ == null)
{
Header = new global::TrdCommon.TrdHeader();
}
Header.MergeFrom(other.Header);
}
if (other.filterConditions_ != null)
{
if (filterConditions_ == null)
{
FilterConditions = new global::TrdCommon.TrdFilterConditions();
}
FilterConditions.MergeFrom(other.FilterConditions);
}
filterStatusList_.Add(other.filterStatusList_);
_unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
}
protected List <object> FilterSortAndPaging(List <object> data, StoreRequestParameters parameters)
{
FilterConditions fc = null;
try
{
fc = parameters.GridFilters;
}
catch (Exception)
{
return(data);
}
//-- start filtering ------------------------------------------------------------
FilterData(data, fc);
//-- end filtering ------------------------------------------------------------
//-- start sorting ------------------------------------------------------------
SortData(data, parameters.Sort);
//-- end sorting ------------------------------------------------------------
//-- start paging ------------------------------------------------------------
int limit = parameters.Limit;
if ((parameters.Start + parameters.Limit) > data.Count)
{
limit = data.Count - parameters.Start;
}
List <object> rangeData = (parameters.Start < 0 || limit < 0) ? data : data.GetRange(parameters.Start, limit);
//-- end paging ------------------------------------------------------------
return(rangeData);
}
public void MergeFrom(C2S other)
{
if (other == null)
{
return;
}
if (other.header_ != null)
{
if (header_ == null)
{
Header = new global::TrdCommon.TrdHeader();
}
Header.MergeFrom(other.Header);
}
if (other.filterConditions_ != null)
{
if (filterConditions_ == null)
{
FilterConditions = new global::TrdCommon.TrdFilterConditions();
}
FilterConditions.MergeFrom(other.FilterConditions);
}
if (other.FilterPLRatioMin != 0D)
{
FilterPLRatioMin = other.FilterPLRatioMin;
}
if (other.FilterPLRatioMax != 0D)
{
FilterPLRatioMax = other.FilterPLRatioMax;
}
_unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
}
public static DataSet GetSpreads(FilterConditions filterConditions)
{
DataTable filteredDataTable = OCHelper.AddRecordsToDataTable(filterConditions);
DataSet dataSet = new DataSet();
DataSet dataSetCE = new DataSet();
DataSet dataSetPE = new DataSet();
if (filterConditions.ContractType.Equals(enumContractType.CE.ToString()))
{
dataSetCE = CalculateSpreads(filteredDataTable, enumContractType.CE.ToString(), filterConditions);
dataSet = OCHelper.MergeDataSets(dataSet, dataSetCE);
}
if (filterConditions.ContractType.Equals(enumContractType.PE.ToString()))
{
dataSetPE = CalculateSpreads(filteredDataTable, enumContractType.PE.ToString(), filterConditions);
dataSet = OCHelper.MergeDataSets(dataSet, dataSetPE);
}
if (filterConditions.ContractType.Equals("ALL"))
{
dataSetCE = CalculateSpreads(filteredDataTable, enumContractType.CE.ToString(), filterConditions);
dataSet = OCHelper.MergeDataSets(dataSet, dataSetCE);
dataSetPE = CalculateSpreads(filteredDataTable, enumContractType.PE.ToString(), filterConditions);
dataSet = OCHelper.MergeDataSets(dataSet, dataSetPE);
}
return(dataSet);
}
public override int GetHashCode()
{
int hash = 1;
if (header_ != null)
{
hash ^= Header.GetHashCode();
}
if (filterConditions_ != null)
{
hash ^= FilterConditions.GetHashCode();
}
if (FilterPLRatioMin != 0D)
{
hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(FilterPLRatioMin);
}
if (FilterPLRatioMax != 0D)
{
hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(FilterPLRatioMax);
}
if (_unknownFields != null)
{
hash ^= _unknownFields.GetHashCode();
}
return(hash);
}
public QueryDefinition GenerateQuery()
{
var query = new QueryDefinition(RecordType);
query.Distinct = true;
if (IsQuickFind)
{
query.IsQuickFind = true;
query.QuickFindText = QuickFindText;
if (!string.IsNullOrWhiteSpace(QuickFindText))
{
var quickFindFields = RecordService.GetStringQuickfindFields(RecordType);
//there was a bug in SDK when querying on queues
//which required adding our or filter as a child filter
//rather than adding in the root filter
var nestedFilter = new Filter();
nestedFilter.ConditionOperator = FilterOperator.Or;
nestedFilter.Conditions.AddRange(quickFindFields.Select(f => new Condition(f, ConditionType.BeginsWith, QuickFindText)));
query.RootFilter.SubFilters.Add(nestedFilter);
}
}
else
{
query.RootFilter = FilterConditions.GetAsFilter();
query.Joins = Joins.GetAsJoins().ToList();
}
var view = DynamicGridViewModel.RecordService.GetView(DynamicGridViewModel.RecordType, DynamicGridViewModel.ViewType);
query.Sorts = view.Sorts.ToList();
return(query);
}
public string GetConditonSQL(string conditions)
{
string _con = "";
if (!string.IsNullOrEmpty(conditions))
{
FilterConditions fc = new FilterConditions(conditions);
foreach (FilterCondition condition in fc.Conditions)
{
Comparison comparison = condition.Comparison;
string field = condition.Name;
FilterType type = condition.FilterType;
switch (condition.FilterType)
{
case FilterType.Date:
if(comparison.ToString()=="Lt")
_con += "and " + field + " >= '" + condition.Value+"'";
else if(comparison.ToString()=="Gt")
_con += "and " + field + " <= '" + condition.Value + "'";
else
_con += "and CONVERT(varchar(100), "+field+", 111) = '" + condition.Value + "'";
break;
case FilterType.Numeric:
_con += "and "+field + " > " + condition.Value;
break;
case FilterType.String:
_con += "and " + field + " like '%" + condition.Value + "%' ";
break;
}
}
_con = _con.Substring(3);
}
return _con;
}
public static DataSet FilterAllStrategies(FilterConditions filterConditions)
{
DataSet InputDataSet = GetFilterAllStrategies(filterConditions);
DataSet dataSetResult = new DataSet();
bool isAddThisTable = true;
foreach (DataTable dataTable in InputDataSet.Tables)
{
//Reset flag for new dataset
isAddThisTable = true;
for (int irowcount = 0; irowcount < dataTable.Rows.Count; irowcount++)
{
if (Convert.ToInt32(dataTable.Rows[irowcount]["Profit/Loss"]) > 0)
{
isAddThisTable = false;
}
}
if (isAddThisTable)
{
dataSetResult.Tables.Add(dataTable.Copy());
}
}
return(dataSetResult);
}
/// <summary>
/// Get list of all messages.
/// </summary>
/// <param name="userId"></param>
/// <param name="filterConditions"></param>
/// <returns></returns>
public async Task <IList <Message> > GetAsync(string userId, FilterConditions filterConditions)
{
if (filterConditions == null)
{
filterConditions = new FilterConditions();
}
// Get all message for specific user
return(await _officeMessageManager.GetAsync(userId, filterConditions).ConfigureAwait(false));
}
public bool Validate()
{
var result = true;
if (FilterConditions != null)
{
result = FilterConditions.Validate();
}
return(result);
}
public async Task <IList <Message> > GetAsync(string userId, FilterConditions filterConditions)
{
StringBuilder urlBuilder = new StringBuilder($"users/{userId}/");
switch (filterConditions.Folder)
{
case Folder.All:
urlBuilder.Append($"messages");
break;
case Folder.DeletedItems:
urlBuilder.Append($"mailFolders('DeletedItems')/messages");
break;
case Folder.Drafts:
urlBuilder.Append($"mailFolders('Drafts')/messages");
break;
case Folder.Inbox:
urlBuilder.Append($"mailFolders('Inbox')/messages");
break;
case Folder.SentItems:
urlBuilder.Append($"mailFolders('SentItems')/messages");
break;
}
if (!string.IsNullOrEmpty(filterConditions.ConversationId))
{
urlBuilder.Append($"?$filter=conversationId%20eq%20'{filterConditions.ConversationId}'&$top={filterConditions.Top}");
}
else if (!string.IsNullOrEmpty(filterConditions.SearchText))
{
urlBuilder.Append($"?$search=\"{filterConditions.SearchText}\"&$top={filterConditions.Top}");
}
else if (filterConditions.Unread.HasValue)
{
urlBuilder.Append($"?$filter=isRead eq {!filterConditions.Unread.Value} And ReceivedDateTime ge {filterConditions.LastReceivedDateTime} ");
}
else if (!string.IsNullOrEmpty(filterConditions.LastReceivedDateTime))
{
urlBuilder.Append($"?$filter= ReceivedDateTime ge {filterConditions.LastReceivedDateTime}");
}
else
{
urlBuilder.Append($"?$count={filterConditions.Count.ToString().ToLower()}");
urlBuilder.Append($"&$orderby={filterConditions.OrderBy.GetEnumDescription()}");
urlBuilder.Append($"&$skip={filterConditions.Skip}");
urlBuilder.Append($"&$top={filterConditions.Top}");
}
urlBuilder.Append($"&$expand=attachments($select=id,lastModifiedDateTime,name,contentType,size)");
return(await _call.GetAsync <IList <Message> >(urlBuilder.ToString()).ConfigureAwait(false));
}
/// <summary>
/// 将Ext.Net的参数中的过滤参数转换成条件链表
/// </summary>
/// <param name="e"></param>
/// <returns></returns>
public static FilterLinked ConvertToFilterLinked(StoreReadDataEventArgs e, Func <FilterCondition, object> converter = null)
{
FilterLinked filterLinked = null;
if (string.IsNullOrEmpty(e.Parameters["filter"]))
{
return(filterLinked);
}
FilterConditions filters = new FilterConditions(e.Parameters["filter"]);
foreach (var item in filters.Conditions)
{
SqlFilter filter = null;
string field = item.Field;
if (converter != null)
{
//执行开发者指定的转换，返回null将进行默认的转换
var result = converter(item);
if (result != null)
{
if (result is SqlFilter)
{
filter = result as SqlFilter;
}
else if (result is string)
{
field = Convert.ToString(result);
}
else
{
throw new ArgumentException("ConvertToFilterLinked方法中的converter参数中的返回值只能是string型或FilterLinked型，为string型表示只自定义转换字段名，为SqlFilter型时表示完全自定义");
}
}
else
{
filter = ConvertToFilter(item, field);
}
}
if (filter == null)
{
filter = ConvertToFilter(item, field);
}
if (filterLinked == null)
{
filterLinked = new FilterLinked(filter);
}
else
{
filterLinked.AddFilter(LogicOperation.And, filter);
}
}
return(filterLinked);
}
public void Populate(JMMServerBinary.Contract_GroupFilter contract)
{
this.GroupFilterID = contract.GroupFilterID;
this.GroupFilterName = contract.GroupFilterName;
this.ApplyToSeries = contract.ApplyToSeries;
this.BaseCondition = contract.BaseCondition;
this.PredefinedCriteria = "";
this.FilterConditions.Clear();
GroupCount = 0;
SeriesCount = 0;
if (contract.FilterConditions != null)
{
foreach (JMMServerBinary.Contract_GroupFilterCondition gfc_con in contract.FilterConditions)
{
FilterConditions.Add(new GroupFilterConditionVM(gfc_con));
}
}
//SortCriteriaList = new ObservableCollection<GroupFilterSortingCriteria>();
SortCriteriaList.Clear();
string sortCriteriaRaw = contract.SortingCriteria;
if (!string.IsNullOrEmpty(sortCriteriaRaw))
{
string[] scrit = sortCriteriaRaw.Split('|');
foreach (string sortpair in scrit)
{
string[] spair = sortpair.Split(';');
if (spair.Length != 2)
{
continue;
}
int stype = 0;
int sdir = 0;
int.TryParse(spair[0], out stype);
int.TryParse(spair[1], out sdir);
if (stype > 0 && sdir > 0)
{
GroupFilterSortingCriteria gfsc = new GroupFilterSortingCriteria();
gfsc.GroupFilterID = this.GroupFilterID;
gfsc.SortType = (GroupFilterSorting)stype;
gfsc.SortDirection = (GroupFilterSortDirection)sdir;
SortCriteriaList.Add(gfsc);
}
}
}
//FilterConditions = new List<GroupFilterConditionVM>(FilterConditions.OrderBy(p => p.ConditionTypeString));
}
private void UnGroupSelected(FilterConditionsViewModel filterConditions = null, FilterConditionsViewModel parentFilterConditions = null)
{
FilterConditions?.UnGroupSelected(null);
if (Joins != null && Joins.Joins != null)
{
foreach (var join in Joins.Joins)
{
join.UngroupSelectedConditions();
}
}
RefreshConditionButtons();
}
private void DeleteSelected()
{
FilterConditions?.DeleteSelected(null);
if (Joins != null && Joins.Joins != null)
{
foreach (var join in Joins.Joins)
{
join.DeleteSelectedConditions();
}
}
RefreshConditionButtons();
}
private void GroupSelected(FilterOperator filterOperator)
{
FilterConditions?.GroupSelected(filterOperator);
if (Joins != null && Joins.Joins != null)
{
foreach (var join in Joins.Joins)
{
join.GroupSelected(filterOperator);
}
}
RefreshConditionButtons();
}
public Filter GetAsFilter()
{
var filter = new Filter();
filter.ConditionOperator = FilterOperator;
filter.Conditions = Conditions
.Select(c => c.GetAsCondition())
.Where(c => c.FieldName != null)
.ToList();
filter.SubFilters = FilterConditions
.Select(c => c.GetAsFilter())
.ToList();
return(filter);
}
public QueryDefinition GenerateQuery()
{
var query = new QueryDefinition(RecordType);
query.Distinct = true;
if (IsQuickFind)
{
query.IsQuickFind = true;
query.QuickFindText = QuickFindText;
if (!string.IsNullOrWhiteSpace(QuickFindText))
{
var quickFindFields = RecordService.GetStringQuickfindFields(RecordType);
//there was a bug in SDK when querying on queues
//which required adding our or filter as a child filter
//rather than adding in the root filter
var nestedFilter = new Filter();
nestedFilter.ConditionOperator = FilterOperator.Or;
nestedFilter.Conditions.AddRange(quickFindFields.Select(f => new Condition(f, ConditionType.BeginsWith, QuickFindText)));
query.RootFilter.SubFilters.Add(nestedFilter);
}
}
else
{
query.RootFilter = FilterConditions.GetAsFilter();
query.Joins = Joins.GetAsJoins().ToList();
}
var view = DynamicGridViewModel.RecordService.GetView(DynamicGridViewModel.RecordType, DynamicGridViewModel.ViewType);
query.Sorts = view.Sorts.Where(s => !s.FieldName.Contains(".")).ToList();
//okay lets add joins for all the columns in referenced types
if (ExplicitlySelectedColumns != null)
{
var linkGroups = ExplicitlySelectedColumns
.Where(c => c.AliasedFieldName != null)
.GroupBy(c => c.AliasedFieldName.Split('.')[0]);
foreach (var linkGroup in linkGroups)
{
var joinToRecordType = linkGroup.First().AltRecordType;
var lookupField = linkGroup.Key.Substring(0, linkGroup.Key.Length - (joinToRecordType.Length + 1));
var join = new Join(lookupField, joinToRecordType, RecordService.GetPrimaryKey(joinToRecordType));
join.JoinType = JoinType.LeftOuter;
join.Fields = linkGroup.Select(lgf => lgf.FieldName);
join.Alias = linkGroup.Key;
query.Joins.Add(join);
}
}
return(query);
}
public void DeleteSelected(FilterConditionsViewModel parentFilterConditions)
{
var isRootFilter = parentFilterConditions == null;
foreach (var item in Conditions.Where(c => c.QueryConditionObject.IsSelected).ToArray())
{
Conditions.Remove(item);
}
foreach (var item in FilterConditions.ToArray())
{
item.DeleteSelected(this);
}
CheckRemoveFilter(parentFilterConditions);
}
/// <summary>
/// 将Ext.Net的参数中的过滤参数转换成条件链表
/// </summary>
/// <param name="e"></param>
/// <returns></returns>
public static IList <SqlFilter> ConvertToFilters(FilterConditions e)
{
IList <SqlFilter> filters = new List <SqlFilter>();
if (e == null || e.Conditions == null)
{
return(filters);
}
foreach (var item in e.Conditions)
{
SqlFilter filter = ConvertToFilter(item, item.Field);
filters.Add(filter);
}
return(filters);
}
public override bool Equals(object obj)
{
if (obj is SelectStatement statement)
{
return(Kind == statement.Kind &&
Class == statement.Class &&
OutputColumns.SequenceEqual(statement.OutputColumns) &&
(MainSource == statement.MainSource || MainSource.Equals(statement.MainSource)) &&
(FilterConditions == statement.FilterConditions || FilterConditions.Equals(statement.FilterConditions)) &&
OutputOrder.SequenceEqual(statement.OutputOrder));
}
else
{
return(false);
}
}
private bool ValidateCurrentSearch()
{
var result = true;
if (!IsQuickFind)
{
result = FilterConditions.Validate();
var joinValidate = Joins.Validate();
if (!joinValidate)
{
result = false;
}
}
return(result);
}
private void AddCondition(FilterOperators filterOperator, TPropEnum prop, FilterConditions condition, object val)
{
if (PredicateFilters == null)
{
PredicateFilters = new QueryFilters <TPropEnum>();
}
if (CurrentExpression == null)
{
PredicateFilters.Add(QueryFilter.New(prop, condition, filterOperator, val));
return;
}
var filter = QueryFilter.New(prop, condition, CurrentExpression.Operator, val);
filter.StartExpressions = CurrentExpression.OpenExpressions;
PredicateFilters.Add(filter);
CurrentExpression = null;
}
private void InitializeConditions(Collection <FilterCondition> conditions)
{
foreach (var condition in conditions.Where(c => !(c is ScriptFilterCondition)))
{
FilterConditionViewModel itemViewModel = new FilterConditionViewModel(requiredValues, condition);
itemViewModel.PropertyChanged += ItemViewModel_PropertyChanged;
FilterConditions.Add(itemViewModel);
}
scriptFilterCondition = conditions.OfType <ScriptFilterCondition>().FirstOrDefault();
if (scriptFilterCondition == null)
{
scriptFilterCondition = new ScriptFilterCondition();
scriptFilterCondition.ScriptType = FilterStyleScriptType;
conditions.Add(scriptFilterCondition);
}
}
public FileResult ExportToExcel(string filters, string sorters, string columns)
{
List <object> dataToExport = GetData();
FilterConditions condition;
DataSorter[] sts;
List <VisableColumn> cols;
if (!string.IsNullOrEmpty(filters))
{
condition = new FilterConditions(filters);
FilterData(dataToExport, condition);
}
if (!string.IsNullOrEmpty(sorters))
{
sts = JSON.Deserialize <DataSorter[]>(sorters,
(IContractResolver) new CamelCasePropertyNamesContractResolver());
SortData(dataToExport, sts);
}
cols = JSON.Deserialize <List <VisableColumn> >(columns);
DataTable dt = ConvertToDataTable(dataToExport, cols);
using (var pck = new OfficeOpenXml.ExcelPackage())
{
int rowIndex = 1;
var ws = pck.Workbook.Worksheets.Add("数据导出");
for (int colIndex = 0; colIndex < cols.Count; colIndex++)
{
ws.Cells[rowIndex, colIndex + 1].Value = cols[colIndex].text;
}
foreach (DataRow dr in dt.Rows)
{
rowIndex++;
for (int colIndex = 0; colIndex < cols.Count; colIndex++)
{
ws.Cells[rowIndex, colIndex + 1].Value = dr[cols[colIndex].dataIndex];
}
}
return(new FileContentResult(pck.GetAsByteArray(), "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"));
}
}
private static DataSet GetFilterAllStrategies(FilterConditions filterConditions)
{
DataSet dataSetResult = new DataSet();
DataTable filteredDataTable = OCHelper.AddRecordsToDataTable(filterConditions);
DataSet dataSetCEBF = new DataSet();
DataSet dataSetPEBF = new DataSet();
DataSet dataSetPEIC = new DataSet();
dataSetCEBF = Butterfly.GetButterflySpreadStrategies(filteredDataTable, enumContractType.CE.ToString(), filterConditions);
dataSetResult = OCHelper.MergeDataSets(dataSetResult, dataSetCEBF);
dataSetPEBF = Butterfly.GetButterflySpreadStrategies(filteredDataTable, enumContractType.PE.ToString(), filterConditions);
dataSetResult = OCHelper.MergeDataSets(dataSetResult, dataSetPEBF);
dataSetPEIC = IronCondorClass.CalculateIronCondors(filteredDataTable, filterConditions);
dataSetResult = OCHelper.MergeDataSets(dataSetResult, dataSetPEIC);
return(dataSetResult);
}
public override int GetHashCode()
{
int hash = 1;
if (header_ != null)
{
hash ^= Header.GetHashCode();
}
if (filterConditions_ != null)
{
hash ^= FilterConditions.GetHashCode();
}
hash ^= filterStatusList_.GetHashCode();
if (_unknownFields != null)
{
hash ^= _unknownFields.GetHashCode();
}
return(hash);
}
public string GetConditonSQL(string conditions)
{
string _con = "";
if (!string.IsNullOrEmpty(conditions))
{
FilterConditions fc = new FilterConditions(conditions);
foreach (FilterCondition condition in fc.Conditions)
{
Comparison comparison = condition.Comparison;
string field = condition.Name;
FilterType type = condition.FilterType;
switch (condition.FilterType)
{
case FilterType.Date:
if (comparison.ToString() == "Lt")
{
_con += "and " + field + " >= '" + condition.Value + "'";
}
else if (comparison.ToString() == "Gt")
{
_con += "and " + field + " <= '" + condition.Value + "'";
}
else
{
_con += "and CONVERT(varchar(100), " + field + ", 111) = '" + condition.Value + "'";
}
break;
case FilterType.Numeric:
_con += "and " + field + " > " + condition.Value;
break;
case FilterType.String:
_con += "and " + field + " like '%" + condition.Value + "%' ";
break;
}
}
_con = _con.Substring(3);
}
return(_con);
}
public void UnGroupSelected(FilterConditionsViewModel parentFilterConditions)
{
var isRootFilter = parentFilterConditions == null;
var selectedConditions = SelectedConditions;
if (selectedConditions.Count() > 0 &&
parentFilterConditions != null)
{
foreach (var item in selectedConditions)
{
Conditions.Remove(item);
parentFilterConditions.Conditions.Insert(0, item);
}
}
foreach (var item in FilterConditions.ToArray())
{
item.UnGroupSelected(this);
}
CheckRemoveFilter(parentFilterConditions);
}
public QueryDefinition GenerateQuery()
{
var query = new QueryDefinition(RecordType);
if (IsQuickFind)
{
query.IsQuickFind = true;
query.QuickFindText = QuickFindText;
if (!string.IsNullOrWhiteSpace(QuickFindText))
{
query.RootFilter.Conditions.Add(new Condition(RecordService.GetPrimaryField(DynamicGridViewModel.RecordType), ConditionType.BeginsWith, QuickFindText));
}
}
else
{
query.RootFilter = FilterConditions.GetAsFilter();
}
var view = DynamicGridViewModel.RecordService.GetView(DynamicGridViewModel.RecordType, DynamicGridViewModel.ViewType);
query.Sorts = view.Sorts.ToList();
return(query);
}
public QueryResponse QueryMap(GlymaSessionConfiguration configuration, Guid domainId, Guid nodeId, int maxDepth, bool isFullDomainSearch, EdgeConditions edgeConditions, FilterConditions filterConditions, int objectIndex)
{
using (IGlymaSession glymaSession = new SvcAppSPGlymaSession(configuration))
{
return Base.QueryMap(glymaSession, domainId, nodeId, maxDepth, isFullDomainSearch, edgeConditions, filterConditions, objectIndex);
}
}
public QueryResponse QueryMapByDomain(string callingUrl, Guid domainId, int maxDepth, EdgeConditions edgeConditions, FilterConditions filterConditions)
{
using (GlymaNSApp.NodeServiceClient nodeServiceClient = new GlymaNSApp.NodeServiceClient(callingUrl))
{
/// This method requires security trimming so there is no need to check authentication here.
using (WebAppSPGlymaSession glymaSession = new WebAppSPGlymaSession(callingUrl))
{
GlymaSessionConfiguration configuration = glymaSession.ExportGlymaSession();
QueryResponse allRootMaps = nodeServiceClient.QueryMapByDomain(configuration, domainId, maxDepth, edgeConditions, filterConditions);
/// This method DOES traverse rootmap boundaries.
GlymaSecurityTrimmer securityTrimmer = new GlymaSecurityTrimmer(glymaSession.Web, glymaSession);
QueryResponse trimmedRootMaps = securityTrimmer.TrimResponse(allRootMaps, SPGlymaRightFactory.Instance.RootMapReadRight);
trimmedRootMaps.CompressResponse();
return trimmedRootMaps;
}
}
}
/// <summary>
/// 将Ext.Net的参数中的过滤参数转换成条件链表
/// </summary>
/// <param name="e"></param>
/// <returns></returns>
public static IList<SqlFilter> ConvertToFilters(FilterConditions e)
{
IList<SqlFilter> filters = new List<SqlFilter>();
if(e==null || e.Conditions==null)
{
return filters;
}
foreach (var item in e.Conditions)
{
SqlFilter filter = ConvertToFilter(item, item.Field);
filters.Add(filter);
}
return filters;
}
/// <summary>
/// 将Ext.Net的参数中的过滤参数转换成条件链表
/// </summary>
/// <param name="e"></param>
/// <returns></returns>
public static FilterLinked ConvertToFilterLinked(StoreReadDataEventArgs e, Func<FilterCondition, object> converter = null)
{
FilterLinked filterLinked = null;
if (string.IsNullOrEmpty(e.Parameters["filter"]))
{
return filterLinked;
}
FilterConditions filters = new FilterConditions(e.Parameters["filter"]);
foreach (var item in filters.Conditions)
{
SqlFilter filter = null;
string field = item.Field;
if (converter != null)
{
//执行开发者指定的转换，返回null将进行默认的转换
var result = converter(item);
if (result != null)
{
if (result is SqlFilter)
{
filter = result as SqlFilter;
}
else if (result is string)
{
field = Convert.ToString(result);
}
else
{
throw new ArgumentException("ConvertToFilterLinked方法中的converter参数中的返回值只能是string型或FilterLinked型，为string型表示只自定义转换字段名，为SqlFilter型时表示完全自定义");
}
}
else
{
filter = ConvertToFilter(item, field);
}
}
if (filter == null)
{
filter = ConvertToFilter(item, field);
}
if (filterLinked == null)
{
filterLinked = new FilterLinked(filter);
}
else
{
filterLinked.AddFilter(LogicOperation.And, filter);
}
}
return filterLinked;
}
public QueryResponse QueryMapByDomain(GlymaSessionConfiguration configuration, Guid domainId, int maxDepth, EdgeConditions edgeConditions, FilterConditions filterConditions)
{
QueryResponse result = null;
// run the call against the application proxy
NodeServiceApplicationProxy.Invoke(_serviceContext,
proxy => result = proxy.QueryMapByDomain(configuration, domainId, maxDepth, edgeConditions, filterConditions));
return result;
}
public QueryResponse QueryMapPaged(string callingUrl, Guid domainId, Guid nodeId, int maxDepth, EdgeConditions edgeConditions, FilterConditions filterConditions, int objectIndex)
{
using (GlymaNSApp.NodeServiceClient nodeServiceClient = new GlymaNSApp.NodeServiceClient(callingUrl))
{
/// This method requires security trimming so there is no need to check authentication here.
using (WebAppSPGlymaSession glymaSession = new WebAppSPGlymaSession(callingUrl))
{
GlymaSessionConfiguration configuration = glymaSession.ExportGlymaSession();
/// This method doesn't traverse rootmap boundaries.
GlymaSecurityTrimmer securityTrimmer = new GlymaSecurityTrimmer(glymaSession.Web, glymaSession);
securityTrimmer.CheckRootMapAuthorisationBaseOnNode(domainId, nodeId, SPGlymaRightFactory.Instance.MapReadRight);
QueryResponse response = nodeServiceClient.QueryMapPaged(configuration, domainId, nodeId, maxDepth, edgeConditions, filterConditions, objectIndex);
response.CompressResponse();
return response;
}
}
}
public QueryResponse QueryMap(string callingUrl, Guid domainId, Guid nodeId, int maxDepth, EdgeConditions edgeConditions, FilterConditions filterConditions)
{
using (GlymaNSApp.NodeServiceClient nodeServiceClient = new GlymaNSApp.NodeServiceClient(callingUrl))
{
return nodeServiceClient.QueryMap(callingUrl, domainId, nodeId, maxDepth, edgeConditions, filterConditions);
}
}
public IList<SqlFilter> ToFilters(FilterConditions e)
{
return FilterConverter.ConvertToFilters(e);
}
public QueryResponse QueryMapPaged(GlymaSessionConfiguration configuration, Guid domainId, Guid nodeId, int maxDepth, EdgeConditions edgeConditions, FilterConditions filterConditions, int objectIndex)
{
return QueryMap(configuration, domainId, nodeId, maxDepth, false, edgeConditions, filterConditions, objectIndex);
}
public QueryResponse QueryMap(IGlymaSession glymaSession, Guid domainId, Guid nodeId, int maxDepth, bool isFullDomainSearch, EdgeConditions edgeConditions, FilterConditions filterConditions, int objectIndex, bool isCompressed)
{
if (!isCompressed)
{
TransactionalMappingToolServiceCommonBase.SoftObjectLimit = 3000;
TransactionalMappingToolServiceCommonBase.HardObjectLimit = 4000;
}
else
{
TransactionalMappingToolServiceCommonBase.SoftObjectLimit = 5500;
TransactionalMappingToolServiceCommonBase.HardObjectLimit = 6500;
}
using (IDbConnectionAbstraction mapDbConnection = glymaSession.ConnectionFactory.CreateMapDbConnection())
{
SqlCommand queryMapCommand = new SqlCommand("QueryMap", mapDbConnection.Connection);
queryMapCommand.CommandType = CommandType.StoredProcedure;
queryMapCommand.Parameters.Add(new SqlParameter("@DomainId", domainId));
queryMapCommand.Parameters.Add(new SqlParameter("@NodeId", nodeId));
queryMapCommand.Parameters.Add(new SqlParameter("@Depth", maxDepth));
queryMapCommand.Parameters.Add(new SqlParameter("@FullDomain", isFullDomainSearch));
mapDbConnection.Open();
SqlDataReader queryMapResults = queryMapCommand.ExecuteReader();
QueryResponse queryResponse = new QueryResponse();
List<Node>[] orderedNodes = new List<Node>[maxDepth + 1];
do
{
while (queryMapResults.Read())
{
if (queryMapResults.GetSchemaTable().Select("ColumnName = 'Level'").Length > 0)
{
Node node = new Node();
node.LoadElement(queryMapResults);
List<Node> nodes;
if (orderedNodes[node.Depth] != null)
{
nodes = orderedNodes[node.Depth];
}
else
{
nodes = new List<Node>();
orderedNodes[node.Depth] = nodes;
}
nodes.Add(node);
queryResponse.AddNode(node);
}
else if (queryMapResults.GetSchemaTable().Select("ColumnName = 'MetadataId'").Length > 0)
{
Metadata metadata = new Metadata();
metadata.LoadElement(queryMapResults);
queryResponse.AddMetadata(metadata);
}
else if (queryMapResults.GetSchemaTable().Select("ColumnName = 'DescriptorUid'").Length > 0)
{
Descriptor descriptor = new Descriptor();
descriptor.LoadElement(queryMapResults);
queryResponse.AddDescriptor(descriptor);
}
else if (queryMapResults.GetSchemaTable().Select("ColumnName = 'RelationshipUid'").Length > 0)
{
Relationship relationship = new Relationship();
relationship.LoadElement(queryMapResults);
queryResponse.AddRelationship(relationship);
}
}
}
while (queryMapResults.NextResult());
mapDbConnection.Close();
try
{
mapDbConnection.Open();
AuditLogItem logItem = new AuditLogItem(mapDbConnection.Connection);
logItem.OperationName = "QueryMap";
//logItem.CallingUrl = callingUrl;
logItem.DomainUid = domainId;
logItem.NodeUid = nodeId;
logItem.RootMapUid = null;
logItem.MaxDepth = maxDepth;
logItem.ObjectIndex = objectIndex;
logItem.EdgeConditions = null;
logItem.FilterConditions = null;
logItem.SearchConditions = null;
logItem.PageNumber = null;
logItem.PageSize = null;
logItem.Commit();
mapDbConnection.Close();
}
catch
{
/// Don't do anything. This is here because audit logging is a very low importance task and we don't want it potentially killing the more important tasks at hand.
}
if (!queryResponse.Nodes.ContainsKey(nodeId))
{
queryResponse.ErrorId = 1;
queryResponse.ErrorMessage = "Provided node ID context doesn't exist";
return queryResponse;
}
queryResponse.AttachElements();
queryResponse.NodeContext = queryResponse.Nodes[nodeId];
if (maxDepth > 0 && edgeConditions != null && edgeConditions.EdgeCondition != null)
{
List<Guid> nodesToRemove = new List<Guid>();
List<Guid> relationshipsToRemove = new List<Guid>();
List<Guid> boundaryNodes = new List<Guid>();
List<Guid> boundaryRelationships = new List<Guid>();
for (int i = 1; i <= maxDepth; i++)
{
List<Node> nodes = orderedNodes[i];
foreach (Node node in nodes)
{
bool isBoundaryNode = false;
bool isBoundaryRelationship = false;
bool isNodeIncluded = true;
bool isRelationshipIncluded = true;
Relationship connectingRelationship = queryResponse.Relationships[node.ConnectingRelationship];
if (boundaryNodes.Contains(node.Origin))
{
isBoundaryNode = true;
isBoundaryRelationship = true;
isNodeIncluded = false;
isRelationshipIncluded = false;
}
else
{
EdgeResult relationshipEvalResult = edgeConditions.EdgeCondition.EvaluateCondition(connectingRelationship);
if (relationshipEvalResult.IsEdge.HasValue && relationshipEvalResult.IsEdge.Value)
{
// THis means the relationship was evaluated to be a boundary edge.
isBoundaryRelationship = true;
isRelationshipIncluded = relationshipEvalResult.IsIncluded;
}
EdgeResult nodeEvalResult = edgeConditions.EdgeCondition.EvaluateCondition(node);
if (nodeEvalResult.IsEdge.HasValue && nodeEvalResult.IsEdge.Value)
{
// This means the node was evaluated to be a boundary edge.
isBoundaryNode = true;
isNodeIncluded = nodeEvalResult.IsIncluded;
// The inclusion value for the node trumps the relationship value as the relationship is dependent on the node existing anyway.
isRelationshipIncluded = isNodeIncluded;
}
else if (isBoundaryRelationship)
{
// If the relationship was discovered to be a boundary then this node will be a boundary edge too.
isBoundaryNode = true;
isNodeIncluded = isRelationshipIncluded;
}
}
if (isBoundaryNode)
{
boundaryNodes.Add(node.NodeUid);
}
if (isBoundaryRelationship)
{
boundaryRelationships.Add(connectingRelationship.RelationshipUid);
}
if (!isNodeIncluded)
{
nodesToRemove.Add(node.NodeUid);
}
if (!isRelationshipIncluded)
{
relationshipsToRemove.Add(connectingRelationship.RelationshipUid);
}
}
}
foreach (Guid nodeIdToRemove in nodesToRemove)
{
queryResponse.Nodes.Remove(nodeIdToRemove);
}
foreach (Guid relationshipIdToRemove in relationshipsToRemove)
{
queryResponse.Relationships.Remove(relationshipIdToRemove);
}
}
int totalObjects = queryResponse.CountObjects();
queryResponse.Domain = new Domain();
queryResponse.Domain.DomainUid = domainId;
if (totalObjects > TransactionalMappingToolServiceCommonBase.HardObjectLimit || objectIndex > 0)
{
return queryResponse.GetPage(objectIndex);
}
return queryResponse;
}
}
public QueryResponse QueryMapByDomain(GlymaSessionConfiguration configuration, Guid domainId, int maxDepth, EdgeConditions edgeConditions, FilterConditions filterConditions)
{
using (IGlymaSession glymaSession = new SvcAppSPGlymaSession(configuration))
{
return Base.QueryMapByDomain(glymaSession, domainId, maxDepth, edgeConditions, filterConditions);
}
}
public QueryResponse QueryMapByDomain(IGlymaSession glymaSession, Guid domainId, int maxDepth, EdgeConditions edgeConditions, FilterConditions filterConditions)
{
using (IDbConnectionAbstraction mapDbConnection = glymaSession.ConnectionFactory.CreateMapDbConnection())
{
SqlCommand queryDomainMapCommand = new SqlCommand("SELECT [NodeUid] FROM [Nodes] WHERE DomainUid = @DomainId AND NodeTypeUid = '263754C2-2F31-4D21-B9C4-6509E00A5E94'", mapDbConnection.Connection);
queryDomainMapCommand.CommandType = CommandType.Text;
queryDomainMapCommand.Parameters.Add(new SqlParameter("@DomainId", domainId));
Guid domainNodeId = Guid.Empty;
mapDbConnection.Open();
SqlDataReader queryMapResults = queryDomainMapCommand.ExecuteReader();
if (queryMapResults.HasRows)
{
queryMapResults.Read();
domainNodeId = queryMapResults.GetGuid(0);
}
mapDbConnection.Close();
try
{
mapDbConnection.Open();
AuditLogItem logItem = new AuditLogItem(mapDbConnection.Connection);
logItem.OperationName = "QueryMapByDomain";
//logItem.CallingUrl = callingUrl;
logItem.DomainUid = domainId;
logItem.NodeUid = null;
logItem.RootMapUid = null;
logItem.MaxDepth = maxDepth;
logItem.ObjectIndex = null;
logItem.EdgeConditions = null;
logItem.FilterConditions = null;
logItem.SearchConditions = null;
logItem.PageNumber = null;
logItem.PageSize = null;
logItem.Commit();
mapDbConnection.Close();
}
catch
{
/// Don't do anything. This is here because audit logging is a very low importance task and we don't want it potentially killing the more important tasks at hand.
}
return QueryMap(glymaSession, domainId, domainNodeId, maxDepth, true, edgeConditions, filterConditions, 0);
}
}
public QueryResponse QueryMap(IGlymaSession glymaSession, Guid domainId, Guid nodeId, int maxDepth, bool isFullDomainSearch, EdgeConditions edgeConditions, FilterConditions filterConditions, int objectIndex)
{
return QueryMap(glymaSession, domainId, nodeId, maxDepth, isFullDomainSearch, edgeConditions, filterConditions, objectIndex, true);
}
//public IList<UserRoleInfo> GetUsers(StoreReadDataEventArgs arg2, Func<string, string> fieldMap = null)
//{
// List<object> parameters = null;
// string condition = this.ParseDynamicConditions(arg2, parameters, fieldMap);
// return this._privilegeBase.GetUsers(arg2.Page, arg2.Limit, condition, new object[] { parameters });
//}
private string ParseDynamicConditions(StoreReadDataEventArgs e, List<object> parameters, Func<string, string> fieldMap = null)
{
string str = e.Parameters["filter"];
List<string> list = new List<string>();
if (!string.IsNullOrEmpty(str))
{
FilterConditions conditions = new FilterConditions(str);
foreach (FilterCondition condition in conditions.Conditions)
{
Comparison comparison = condition.Comparison;
string field = condition.Field;
if (fieldMap != null)
{
field = fieldMap(field);
}
string str3 = field.Replace(".", "");
FilterType type = condition.Type;
object obj2 = condition.Value<object>();
if (!(obj2 is JValue))
{
goto Label_0221;
}
JValue value2 = obj2 as JValue;
object obj3 = value2.Value;
switch (value2.Type)
{
case JTokenType.Integer:
obj3 = Convert.ToInt32(obj3);
break;
case JTokenType.Float:
obj3 = Convert.ToDecimal(obj3);
break;
case JTokenType.String:
obj3 = Convert.ToString(obj3);
break;
case JTokenType.Boolean:
obj3 = Convert.ToBoolean(obj3);
break;
case JTokenType.Date:
obj3 = Convert.ToDateTime(obj3);
break;
default:
throw new NotSupportedException("未支持的JTokenType" + value2.Type);
}
switch (comparison)
{
case Comparison.Eq:
if (obj3 != null)
{
break;
}
list.Add(field + " is null");
goto Label_0208;
case Comparison.Gt:
list.Add(field + ">@" + str3);
goto Label_0208;
case Comparison.Lt:
list.Add(field + "<@" + str3);
goto Label_0208;
default:
goto Label_0208;
}
if (type == FilterType.String)
{
list.Add(field + " like '%'+@" + str3 + "+'%'");
}
else
{
list.Add(field + "=@" + str3);
}
Label_0208:
if (obj3 != null)
{
parameters.Add(obj3);
}
continue;
Label_0221:
if (obj2 is JArray)
{
JArray source = obj2 as JArray;
List<int> values = new List<int>();
source.ToList<JToken>().ForEach(delegate(JToken x)
{
values.Add(x.Value<int>());
});
list.Add(field + " in (" + string.Join<int>(",", values) + ")");
}
}
}
return string.Join(" and ", list);
}
