public string GetSearchRequest(ISearchExpression expression, bool onlyMy = true)
{
var queryBuilder = QueryBuilderImpl.CreateEmptyQueryBuilder();
var currentUser = _context.GetCurrentPerson();
var currentUserPositions = currentUser.Positions.ToArray();
var allTasksTypes = _taskTypesService.AllTaskTypes
.Union(_taskTypesService.AllWorkflowTypes)
.ToArray();
var types = GetTypesFromExpression <NextTaskTypeArgumentToken>(expression, allTasksTypes, out _);
queryBuilder.Must(ObjectFields.TypeId.BeAnyOf(types.Select(x => x.Id).ToArray()));
AddAttributesSearch(expression, queryBuilder);
var myToken = expression.Tokens.OfType <NextTaskMySearchToken>().ToList();
if ((!currentUser.IsAdmin && onlyMy) || (!currentUser.IsAdmin && !onlyMy && myToken.Any()) || (currentUser.IsAdmin && myToken.Any()))
{
var occur = myToken.FirstOrDefault()?.Context?.GetTermOccur() ?? TermOccur.Must;
var searchObjects = new List <ISearchTerm>();
var attributeNames = new HashSet <string>();
foreach (var name in allTasksTypes)
{
attributeNames.UnionWith(name.Attributes.Where(x => x.Type == MAttrType.OrgUnit).Select(x => x.Name));
}
foreach (var attribute in attributeNames)
{
var field = AttributeFields.OrgUnit(attribute);
searchObjects.Add(field.BeAnyOf(currentUserPositions));
}
queryBuilder.AddAnyOf(searchObjects.ToArray(), occur);
}
var searchPhraseTokens = expression.Tokens.OfType <NextTaskSearchPhraseToken>();
foreach (var tokenGroup in searchPhraseTokens.GroupBy(x => x.Context.GetTermOccur()))
{
var keywords = tokenGroup.Select(x => EscapeKeyword(x.Value)).ToList();
foreach (var keyword in keywords)
{
queryBuilder.Add(ObjectFields.AllText.Be(keyword), tokenGroup.Key);
}
}
var quotedSearchPhraseTokens = expression.Tokens.OfType <NextTaskQuotedSearchPhraseToken>();
foreach (var tokenGroup in quotedSearchPhraseTokens.GroupBy(x => x.Context.GetTermOccur()))
{
var keywords = tokenGroup.Select(x => EscapeSearchPhrase(x.Value)).ToList();
foreach (var keyword in keywords)
{
queryBuilder.Add(ObjectFields.AllText.Be(keyword), tokenGroup.Key);
}
}
return(queryBuilder.ToString());
}
private ISearchExpression RemoveParentSelectAsExpression(ISearchExpression exp)
{
if (m_parentSm.SelectAsColumns == null)
/* || m_innerSearchManager.Count == 0) */ // 不知道为什么有这句话
{
return(exp);
}
Feng.Search.LogicalExpression le = exp as Feng.Search.LogicalExpression;
if (le != null)
{
ISearchExpression sel = RemoveParentSelectAsExpression(le.LeftHandSide);
ISearchExpression ser = RemoveParentSelectAsExpression(le.RightHandSide);
return(new Feng.Search.LogicalExpression(sel, ser, le.LogicOperator));
}
else
{
Feng.Search.SimpleExpression se = exp as Feng.Search.SimpleExpression;
if (se != null)
{
if (m_parentSm.SelectAsColumns.ContainsKey(se.FullPropertyName))
{
return(SearchExpression.True());
}
else
{
return(se);
}
}
}
return(null);
}
/// <summary>
/// 查询数据条数
/// </summary>
/// <param name="searchExpression"></param>
/// <returns></returns>
public override int GetCount(ISearchExpression searchExpression)
{
using (var rep = new Repository(this.RepositoryCfgName))
{
return(GetCount(searchExpression, rep.Session));
}
}
/// <summary>
/// 查询数据
/// </summary>
/// <param name="searchExpression"></param>
/// <param name="searchOrders"></param>
/// <returns></returns>
public override System.Collections.IEnumerable GetData(ISearchExpression searchExpression, IList <ISearchOrder> searchOrders)
{
using (var rep = new Repository(this.RepositoryCfgName))
{
return(GetData(searchExpression, searchOrders, rep.Session));
}
}
/// <summary>
/// 根据查询条件读入数据
/// </summary>
/// <param name="searchExpression"></param>
/// <param name="searchOrders"></param>
protected override void GetDataCount(ISearchExpression searchExpression, IList <ISearchOrder> searchOrders)
{
System.Data.DataTable dt = GetData(searchExpression, searchOrders) as System.Data.DataTable;
if (this.EnablePage && m_dataCanPage)
{
base.Count = GetCount(searchExpression);
}
else
{
base.Count = dt.Rows.Count;
}
// 需要分页但数据库读取不能分页的时候，读出全部数据然后选择性返回
if (this.EnablePage && !m_dataCanPage)
{
System.Data.DataTable dt2 = dt.Clone();
for (int i = 0; i < Math.Min(dt.Rows.Count, this.MaxResult); ++i)
{
dt2.ImportRow(dt.Rows[i + this.FirstResult]);
}
base.Result = dt2.DefaultView;
}
else
{
base.Result = dt.DefaultView;
}
}
/// <summary>
///
/// </summary>
/// <param name="searchExpression"></param>
/// <param name="searchOrders"></param>
/// <param name="parentItem"></param>
public override System.Collections.IEnumerable GetData(ISearchExpression searchExpression, IList <ISearchOrder> searchOrders, object parentItem)
{
IList <T> list;
object masterItem = parentItem;
if (masterItem != null)
{
if (masterItem.GetType() == typeof(T))
{
list = new List <T>();
list.Add((T)masterItem);
}
else
{
using (var rep = new Repository(this.RepositoryCfgName))
{
rep.BeginTransaction();
object id = EntityScript.GetPropertyValue(masterItem, TypedEntityMetadata.GenerateEntityInfo(rep.Session.SessionFactory, masterItem.GetType()).IdName);
NHibernate.ICriteria criteria = rep.Session.CreateCriteria(typeof(T))
.Add(NHibernate.Criterion.Expression.IdEq(id));
OnCriteriaCreated(criteria);
list = criteria.List <T>();
rep.CommitTransaction();
}
}
}
else
{
list = new List <T>();
}
return(list);
}
/// <summary>
/// 根据查询条件查询数据
/// </summary>
/// <param name="searchExpression"></param>
/// <param name="searchOrders"></param>
/// <returns></returns>
public override System.Collections.IEnumerable GetData(ISearchExpression searchExpression, IList <ISearchOrder> searchOrders)
{
System.Data.DataTable dt = DbHelper.Instance.ExecuteDataTable(CreateDbCommand(searchExpression, searchOrders));
dt.TableName = m_tableName;
return(dt.DefaultView);
}
/// <summary>
/// 读入数据
/// </summary>
/// <param name="searchExpression"></param>
/// <param name="searchOrders"></param>
protected override void GetDataCount(ISearchExpression searchExpression, IList <ISearchOrder> searchOrders)
{
System.Data.DataTable dt = DbHelper.Instance.ExecuteDataTable(CreateDbCommand(searchExpression, searchOrders));
dt.TableName = m_tableName;
if (this.EnablePage && m_dataCanPage)
{
base.Count = GetCount(searchExpression);
}
else
{
base.Count = dt.Rows.Count;
}
// 需要分页但数据库读取不能分页的时候，读出全部数据然后选择性返回
if (this.EnablePage && !m_dataCanPage)
{
System.Data.DataTable dt2 = dt.Clone();
for (int i = 0; i < Math.Min(dt.Rows.Count - this.FirstResult, this.MaxResult); ++i)
{
dt2.ImportRow(dt.Rows[i + this.FirstResult]);
}
this.Result = dt2.DefaultView;
}
else
{
this.Result = dt.DefaultView;
}
}
private ISearchExpression ParseComplexExpression()
{
ISearchExpression expression = null;
switch (this.token)
{
case TokenType.LeftParenthesis:
this.MoveNext();
ISearchExpression c = this.ParseOrOperator();
this.AssertTokenType(TokenType.RightParenthesis);
expression = c;
break;
case TokenType.Not:
this.MoveNext();
expression = new LogicalExpression(this.ParseComplexExpression(), null, LogicalOperator.Not);
break;
default:
expression = ParseSimpleExpression();
break;
}
return(expression);
}
/// <summary>
///
/// </summary>
/// <param name="searchExpression"></param>
/// <param name="searchOrders"></param>
/// <param name="func"></param>
protected override void GetDataCount(ISearchExpression searchExpression, IList <ISearchOrder> searchOrders,
Action <object> func)
{
List <T> dataSource = new List <T>();
int count;
using (var rep = new Repository(this.RepositoryCfgName))
//using (var tx = rep.BeginTransaction(System.Data.IsolationLevel.ReadCommitted))
{
rep.BeginTransaction();
ActionableList <object> actionList = new ActionableList <object>(dataSource, func);
GetData(searchExpression, searchOrders, rep.Session, actionList);
// 当不是第一页的时候，不能通过返回条数当作总条数
if (this.EnablePage && this.FirstResult == 0 && dataSource.Count < this.MaxResult)
{
count = dataSource.Count;
}
else
{
count = GetCount(searchExpression, rep.Session);
}
rep.CommitTransaction();
}
base.Count = count;
base.Result = dataSource;
}
internal static Dictionary <string, object> GetSearchExpreesionValues(ISearchExpression se)
{
Dictionary <string, object> ret = new Dictionary <string, object>();
Feng.Search.LogicalExpression le = se as Feng.Search.LogicalExpression;
if (le != null)
{
Dictionary <string, object> r = GetSearchExpreesionValues(le.LeftHandSide);
foreach (KeyValuePair <string, object> kvp in r)
{
ret[kvp.Key] = kvp.Value;
}
r = GetSearchExpreesionValues(le.RightHandSide);
foreach (KeyValuePair <string, object> kvp in r)
{
ret[kvp.Key] = kvp.Value;
}
}
else
{
Feng.Search.SimpleExpression ce = se as Feng.Search.SimpleExpression;
ret[ce.FullPropertyName + ce.Operator.ToString()] = ce.Values;
}
return(ret);
}
/// <summary>
/// 读入数据
/// </summary>
/// <param name="searchExpression"></param>
/// <param name="searchOrders"></param>
protected override void GetDataCount(ISearchExpression searchExpression, IList <ISearchOrder> searchOrders)
{
System.Data.DataTable dt = DbHelper.Instance.ExecuteDataTable(CreateDbCommand(searchExpression, searchOrders));
base.Result = dt.DefaultView;
base.Count = dt.Rows.Count;
}
/// <summary>
/// 把SearchExpression分解成SimpleExpression列表
/// </summary>
/// <param name="searchExpression"></param>
/// <returns></returns>
public static IList <SimpleExpression> GetSimpleExpressions(ISearchExpression searchExpression)
{
List <SimpleExpression> list = new List <SimpleExpression>();
GetSimpleExpressions(searchExpression, list);
return(list);
}
public string ToInvariantExpressionString(ISearchExpression expression)
{
var sb = new StringBuilder();
foreach (var token in expression.Tokens)
{
var keywordToken = token as IKeywordToken;
if (keywordToken != null)
{
sb.Append(keywordToken.SerializationAlias);
continue;
}
var argumentToken = token as IArgumentToken;
if (argumentToken != null)
{
sb.Append(argumentToken.Id ?? argumentToken.Value);
continue;
}
throw new InvalidOperationException("unknown token class");
}
return(sb.ToString());
}
public void Visit(ISearchExpression expression)
{
var p = expression as ISearchExpression;
string lf = "";
string lv = "";
string rf = "";
string rv = "";
if (p.Left != null || p.Right != null)
{
if (p.Left != null)
{
lf = p.Left.FieldName;
lv = p.Left.Value;
}
if (p.Right != null)
{
rf = p.Right.FieldName;
rv = p.Right.Value;
}
param.Add(String.Format("LEFT Field: {0} Value: {1} {2} RIGHT Field: {3} Value: {4}", lf, lv, p.ExpressionType, rf, rv));
Count++;
}
}
internal void GetDataCountInternal(ISearchExpression searchExpression, IList <ISearchOrder> searchOrders)
{
IList <T> dataSource;
int count;
using (var rep = new Repository(this.RepositoryCfgName))
//using (var tx = rep.BeginTransaction(System.Data.IsolationLevel.ReadCommitted))
{
rep.BeginTransaction();
dataSource = GetData(searchExpression, searchOrders, rep.Session) as IList <T>;
// 当不是第一页的时候，不能通过返回条数当作总条数
if (this.EnablePage && this.FirstResult == 0 && dataSource.Count < this.MaxResult)
{
count = dataSource.Count;
}
else
{
count = GetCount(searchExpression, rep.Session);
}
rep.CommitTransaction();
}
base.Count = count;
base.Result = dataSource;
}
/// <summary>
/// 以entities为数据打印（例如滞箱费减免联系单）
/// </summary>
/// <param name="entities"></param>
public void FillDataSet(object[] entities)
{
ISearchExpression se = null;
foreach (object entity in entities)
{
if (se == null)
{
se = SearchExpression.Parse(EntityHelper.ReplaceEntity(m_reportInfo.SearchExpression, entity));
}
else
{
se = SearchExpression.Or(se, SearchExpression.Parse(EntityHelper.ReplaceEntity(m_reportInfo.SearchExpression, entity)));
}
}
for (int i = 0; i < m_reportDataInfos.Count; ++i)
{
object data = m_sms[i].GetData(se, null);
System.Collections.IEnumerable dataList = data as System.Collections.IEnumerable;
if (dataList == null)
{
dataList = (data as System.Data.DataTable).DefaultView;
}
FillDataSet(i, dataList);
}
}
/// <summary>
/// 根据查询条件创建Sql命令
/// </summary>
/// <param name="searchExpression"></param>
/// <param name="searchOrders"></param>
/// <returns></returns>
public virtual DbCommand CreateDbCommand(ISearchExpression searchExpression, IList <ISearchOrder> searchOrders)
{
DbCommand cmd = DbHelper.Instance.Database.DbProviderFactory.CreateCommand();
cmd.CommandType = System.Data.CommandType.Text;
if (searchExpression is QueryExpression)
{
string s = (searchExpression as QueryExpression).Query;
cmd.CommandText = s;
}
else
{
int paramCnt = 0;
if (this.EnablePage && m_dataCanPage)
{
}
else
{
cmd.CommandText = m_selectSql;
// Add Where
if (searchExpression != null)
{
string s = SearchManager.FillDbCommand(searchExpression, cmd.Parameters, false, ref paramCnt, m_selectAsColumns);
if (!string.IsNullOrEmpty(s))
{
cmd.CommandText += " WHERE " + s;
}
}
string groupBy = SearchManager.GetGroupCommand(m_groupBySql);
if (!string.IsNullOrEmpty(groupBy))
{
cmd.CommandText += groupBy;
// Add Having
if (searchExpression != null)
{
string s = SearchManager.FillDbCommand(searchExpression, cmd.Parameters, true, ref paramCnt, m_selectAsColumns);
if (!string.IsNullOrEmpty(s))
{
cmd.CommandText += " HAVING " + s;
}
}
}
cmd.CommandText += SearchManager.GetSqlOrders(searchOrders, false, null);
}
if (paramCnt > 2100)
{
throw new NotSupportedException("您输入的参数过多，系统最多只支持2100个参数！");
}
}
return(cmd);
}
private ObjectState[] GetObjectStates(ISearchExpression expression)
{
var stateToken = expression.Tokens.OfType <StateArgumentToken>().FirstOrDefault();
return(stateToken != null
? new[] { (ObjectState)Enum.Parse(typeof(ObjectState), stateToken.Id, true) }
: new[] { ObjectState.Alive, ObjectState.Frozen });
}
private void GetData(ISearchExpression searchExpression, IList <ISearchOrder> searchOrders,
NHibernate.ISession session, ActionableList <object> actionList)
{
NHibernate.ICriteria criteria = CreateCriteria(session, searchExpression, searchOrders, ref m_hasCollection);
OnCriteriaCreated(criteria);
criteria.List(actionList);
}
private System.Collections.IEnumerable GetData(ISearchExpression searchExpression, IList <ISearchOrder> searchOrders, NHibernate.ISession session)
{
NHibernate.ICriteria criteria = CreateCriteria(session, searchExpression, searchOrders, ref m_hasCollection);
OnCriteriaCreated(criteria);
return(criteria.List <T>());
//return criteria.Future<T>();
}
internal static void ShowFrom(string actionId, ISearchExpression se, bool asDetailDialog)
{
IDisplayManagerContainer seeForm = null;
ArchiveDetailForm detailForm = null;
ISearchManager sm = null;
if (!asDetailDialog)
{
seeForm = (ServiceProvider.GetService <IApplication>() as IWinFormApplication).ExecuteAction(actionId) as IDisplayManagerContainer;
if (seeForm == null)
{
throw new InvalidOperationException("未能创建目标窗体！");
}
sm = seeForm.DisplayManager.SearchManager;
}
else
{
//detailForm = Feng.Utils.ReflectionHelper.CreateInstanceFromType(Feng.Utils.ReflectionHelper.GetTypeFromName(info.ToDetailForm)) as ArchiveDetailForm;
//if (detailForm == null)
//{
// MessageForm.ShowError("未能创建目标窗体！");
// return;
//}
//detailForm.UpdateContent();
//findWindow = detailForm.DisplayManager.SearchManager;
}
if (sm == null)
{
throw new InvalidOperationException("未能找到目标窗体的查找窗口！");
}
//List<ISearchExpression> findList = new List<ISearchExpression>();
//ISearchExpression findCondition = GetAndFindCondition(selected, 0, toColumns);
//for (int i = 1; i < selected[0].Count; ++i)
//{
// findCondition = new LogicalExpression(findCondition, GetAndFindCondition(selected, i, toColumns), LogicalOperator.Or);
//}
//findList.Add(findCondition);
sm.LoadData(se, null);
if (asDetailDialog)
{
if (detailForm.ControlManager.DisplayManager.Count == 0)
{
ServiceProvider.GetService <IMessageBox>().ShowWarning("未能找到相应记录！");
return;
}
detailForm.ControlManager.DisplayManager.Position = 0;
detailForm.ShowDialog();
detailForm.Dispose();
}
}
protected void AddDateSearch(
Func <TokenBase, bool> tokenFilter,
Func <DatesRangeLimits, ISearchTerm> toObjectSearchTerm,
Func <DatesRangeLimits, ISearchTerm> toFileSearchTerm,
ISearchExpression expression,
IQueryBuilder attributesQueryBuilder,
IQueryBuilder filesQueryBuilder)
{
var dateRangeTokens = expression.Tokens.OfType <TokenBase>().Where(x => tokenFilter(x)).ToList();
var dateRangeGroups = dateRangeTokens.GroupBy(x => x.Context[RangeToken.RangeGroupKey].Value).Where(g => g.Key != null);
var dateRanges = new List <DatesRangeLimits>();
foreach (var group in dateRangeGroups)
{
var dateTextPresetToken = (DateTextArgumentToken)group.FirstOrDefault(x => x is DateTextArgumentToken);
if (dateTextPresetToken != null)
{
var presetRange = DatesRangeLimits.GetRangeLimits(dateTextPresetToken);
dateRanges.Add(presetRange);
continue;
}
var groupTail = group.Last();
var from = groupTail.Context[RangeToken.FromValueKey].Value;
var to = groupTail.Context[RangeToken.ToValueKey].Value;
if (from == null || to == null)
{
continue;
}
var range = new DatesRangeLimits((DateTime)from, (DateTime)to);
if (groupTail.Context[RangeToken.RangeKindKey].Value is DateAttributeGreaterToken)
{
range = DatesRangeLimits.GreaterThanRange(range);
}
if (groupTail.Context[RangeToken.RangeKindKey].Value is DateAttributeLessToken)
{
range = DatesRangeLimits.LessThanRange(range);
}
dateRanges.Add(range);
}
if (!dateRanges.Any())
{
return;
}
var context = dateRangeTokens.First().Context;
attributesQueryBuilder?.AddAnyOf(dateRanges.Select(toObjectSearchTerm).ToArray(), context.GetTermOccur());
filesQueryBuilder?.AddAnyOf(dateRanges.Select(toFileSearchTerm).ToArray(), context.GetTermOccur());
}
public ISearchExpression Or(ISearchExpression expression)
{
this.Left = new SearchExpression(this.FieldName, this.Value, this.Left, this.Right, this.ExpressionType);
this.Right = expression;
this.ExpressionType = ExpressionType.Or;
this.FieldName = null;
this.Value = null;
return(this);
}
/// <summary>
///
/// </summary>
/// <param name="searchExpression"></param>
/// <returns></returns>
protected virtual DbCommand CreateCountDbCommand(ISearchExpression searchExpression)
{
DbCommand cmd = DbHelper.Instance.Database.DbProviderFactory.CreateCommand();
cmd.CommandType = System.Data.CommandType.Text;
if (searchExpression is QueryExpression)
{
string str = (searchExpression as QueryExpression).Query;
str = str.ToUpper();
int idx = str.IndexOf(' ');
int idx2 = str.IndexOf("FROM");
str = str.Replace(str.Substring(idx, idx2 - idx), " COUNT(*) ");
cmd.CommandText = str;
return(cmd);
}
int paramCnt = 0;
cmd.CommandText = "SELECT COUNT(*) FROM " + m_tableName;
// Add Where
if (searchExpression != null)
{
string s = FillDbCommand(searchExpression, cmd.Parameters, false, ref paramCnt, m_selectAsColumns);
if (!string.IsNullOrEmpty(s))
{
cmd.CommandText += " WHERE " + s;
}
}
string groupBy = GetGroupCommand(m_groupBySql);
if (!string.IsNullOrEmpty(groupBy))
{
cmd.CommandText += groupBy;
// Add Having
if (searchExpression != null)
{
string s = FillDbCommand(searchExpression, cmd.Parameters, true, ref paramCnt, m_selectAsColumns);
if (!string.IsNullOrEmpty(s))
{
cmd.CommandText += " HAVING " + s;
}
}
}
if (paramCnt > 2100)
{
throw new NotSupportedException("您输入的参数过多，系统最多只支持2100个参数！");
}
return(cmd);
}
/// <summary>
/// ToString
/// </summary>
/// <param name="searchExpressions"></param>
/// <returns></returns>
public static string ToString(ISearchExpression searchExpressions)
{
if (searchExpressions == null)
{
return(string.Empty);
}
else
{
return(searchExpressions.ToString());
}
}
private ISearchExpression AndIfNecessary(ISearchExpression original, ISearchExpression and)
{
if (original != null)
{
return(SearchExpression.And(original, and));
}
else
{
return(and);
}
}
void smMaster_DataLoading(object sender, DataLoadingEventArgs e)
{
e.Cancel = true;
ISearchExpression searchExpression = e.SearchExpression;
IList <ISearchOrder> searchOrders = e.SearchOrders;
ReportGenerator.SetParameter(this.ReportViewer.CrystalHelper, searchExpression);
this.ReportViewer.OpenReport();
}
/// <summary>
///
/// </summary>
/// <param name="searchExpression"></param>
/// <returns></returns>
public override int GetCount(ISearchExpression searchExpression)
{
if (this.EnablePage && m_dataCanPage)
{
return((int)DbHelper.Instance.ExecuteScalar(CreateCountDbCommand(searchExpression)));
}
else
{
return(base.Count);
}
}
/// <summary>
/// 根据可读字符串得到查询条件
/// </summary>
/// <param name="searchExpression"></param>
/// <returns></returns>
public static IList <ISearchExpression> ParseToList(string searchExpression)
{
IList <ISearchExpression> ret = new List <ISearchExpression>();
ISearchExpression exp = SearchExpression.Parse(searchExpression);
if (exp != null)
{
ret.Add(exp);
}
return(ret);
}
/// <summary>
/// 根据查询条件创建Sql命令
/// </summary>
/// <param name="searchExpression"></param>
/// <param name="searchOrders"></param>
/// <returns></returns>
public DbCommand CreateDbCommand(ISearchExpression searchExpression, IList<ISearchOrder> searchOrders)
{
DbCommand cmd = DbHelper.Instance.Database.DbProviderFactory.CreateCommand();
cmd.CommandType = System.Data.CommandType.StoredProcedure;
int paramCnt = 0;
cmd.CommandText = m_procedureName;
FillDbCommand(searchExpression, cmd, ref paramCnt);
return cmd;
}
/// <summary>
///
/// </summary>
/// <param name="searchExpression"></param>
/// <returns></returns>
public virtual DbCommand CreateCountDbCommand(ISearchExpression searchExpression)
{
DbCommand cmd = DbHelper.Instance.Database.DbProviderFactory.CreateCommand();
cmd.CommandType = System.Data.CommandType.Text;
if (searchExpression is QueryExpression)
{
string str = (searchExpression as QueryExpression).Query;
str = str.ToUpper();
int idx = str.IndexOf("' '");
int idx2 = str.IndexOf("FROM");
str = str.Replace(str.Substring(idx, idx2 - idx), " COUNT(*) ");
cmd.CommandText = str;
}
else
{
int paramCnt = 0;
// Add Where
if (searchExpression != null)
{
string s = SearchManager.FillDbCommand(searchExpression, cmd.Parameters, false, ref paramCnt, m_selectAsColumns);
if (!string.IsNullOrEmpty(s))
{
cmd.CommandText += " WHERE " + s;
}
}
string groupBy = SearchManager.GetGroupCommand(m_groupBySql);
if (!string.IsNullOrEmpty(groupBy))
{
cmd.CommandText += groupBy;
// Add Having
if (searchExpression != null)
{
string s = SearchManager.FillDbCommand(searchExpression, cmd.Parameters, true, ref paramCnt, m_selectAsColumns);
if (!string.IsNullOrEmpty(s))
{
cmd.CommandText += " HAVING " + s;
}
}
}
if (paramCnt > 2100)
{
throw new NotSupportedException("您输入的参数过多，系统最多只支持2100个参数！");
}
}
return cmd;
}
/// <summary>
///
/// </summary>
/// <param name="lhs"></param>
/// <param name="rhs"></param>
/// <returns></returns>
public static ISearchExpression And(ISearchExpression lhs, ISearchExpression rhs)
{
if (lhs == null)
{
return rhs;
}
else if (rhs == null)
{
return lhs;
}
else
{
return new LogicalExpression(lhs, rhs, LogicalOperator.And);
}
}
/// <summary>
///
/// </summary>
/// <param name="searchExpression"></param>
/// <returns></returns>
protected override DbCommand CreateCountDbCommand(ISearchExpression searchExpression)
{
Dictionary<string, object> dict = new Dictionary<string, object>();
ISearchExpression newSe = RemoveFunctionParamSearchExpression(searchExpression, dict);
DbCommand cmd = base.CreateCountDbCommand(newSe);
foreach (string funcParam in m_funcParams)
{
cmd.Parameters.Add(DbHelper.Instance.CreateParameter(funcParam, dict.ContainsKey(funcParam) ? dict[funcParam] : System.DBNull.Value));
}
//ProcessCmd(cmd);
return cmd;
}
internal static Dictionary<string, object> GetSearchExpreesionValues(ISearchExpression se)
{
Dictionary<string, object> ret = new Dictionary<string, object>();
Feng.Search.LogicalExpression le = se as Feng.Search.LogicalExpression;
if (le != null)
{
Dictionary<string, object> r = GetSearchExpreesionValues(le.LeftHandSide);
foreach (KeyValuePair<string, object> kvp in r)
{
ret[kvp.Key] = kvp.Value;
}
r = GetSearchExpreesionValues(le.RightHandSide);
foreach (KeyValuePair<string, object> kvp in r)
{
ret[kvp.Key] = kvp.Value;
}
}
else
{
Feng.Search.SimpleExpression ce = se as Feng.Search.SimpleExpression;
ret[ce.FullPropertyName + ce.Operator.ToString()] = ce.Values;
}
return ret;
}
private static void GetSimpleExpressions(ISearchExpression searchExpression, List<SimpleExpression> list)
{
if (searchExpression is SimpleExpression)
{
list.Add(searchExpression as SimpleExpression);
}
else if (searchExpression is LogicalExpression)
{
LogicalExpression le = searchExpression as LogicalExpression;
if (le.LogicOperator == LogicalOperator.And || le.LogicOperator == LogicalOperator.Or)
{
GetSimpleExpressions(le.LeftHandSide, list);
GetSimpleExpressions(le.RightHandSide, list);
}
else if (le.LogicOperator == LogicalOperator.Not)
{
GetSimpleExpressions(le.LeftHandSide, list);
}
}
}
internal static void SetParameter(CrystalHelper crystalHelper, ISearchExpression se)
{
if (se == null)
return;
LogicalExpression le = se as LogicalExpression;
if (le != null)
{
SetParameter(crystalHelper, le.LeftHandSide);
SetParameter(crystalHelper, le.RightHandSide);
}
else
{
SimpleExpression cse = se as SimpleExpression;
string simpleParamName = "@" + cse.FullPropertyName;
string complexParamName = "@" + cse.FullPropertyName + cse.Operator.ToString();
switch (cse.Operator)
{
case SimpleOperator.Any:
case SimpleOperator.EqProperty:
case SimpleOperator.IsNotNull:
case SimpleOperator.IsNull:
case SimpleOperator.NotEq:
case SimpleOperator.NotEqProperty:
case SimpleOperator.Sql:
throw new ArgumentException(cse.Operator + " is not supported in procedure!");
case SimpleOperator.Ge:
case SimpleOperator.Gt:
case SimpleOperator.Le:
case SimpleOperator.Lt:
crystalHelper.SetParameter(complexParamName, cse.Values);
break;
case SimpleOperator.Eq:
case SimpleOperator.GInG:
case SimpleOperator.InG:
case SimpleOperator.Like:
crystalHelper.SetParameter(simpleParamName, cse.Values);
break;
}
}
}
/// <summary>
/// 查询数据条数
/// </summary>
/// <param name="searchExpression"></param>
/// <returns></returns>
public override int GetCount(ISearchExpression searchExpression)
{
if (this.EnablePage && m_dataCanPage)
{
return (int)DbHelper.Instance.ExecuteScalar(CreateCountDbCommand(searchExpression));
}
else
{
return base.Count;
}
}
private ISearchExpression RemoveParentSelectAsExpression(ISearchExpression exp)
{
if (m_parentSm.SelectAsColumns == null)
/* || m_innerSearchManager.Count == 0) */ // 不知道为什么有这句话
{
return exp;
}
Feng.Search.LogicalExpression le = exp as Feng.Search.LogicalExpression;
if (le != null)
{
ISearchExpression sel = RemoveParentSelectAsExpression(le.LeftHandSide);
ISearchExpression ser = RemoveParentSelectAsExpression(le.RightHandSide);
return new Feng.Search.LogicalExpression(sel, ser, le.LogicOperator);
}
else
{
Feng.Search.SimpleExpression se = exp as Feng.Search.SimpleExpression;
if (se != null)
{
if (m_parentSm.SelectAsColumns.ContainsKey(se.FullPropertyName))
{
return SearchExpression.True();
}
else
{
return se;
}
}
}
return null;
}
/// <summary>
/// 根据查询条件创建Sql命令
/// </summary>
/// <param name="searchExpression"></param>
/// <param name="searchOrders"></param>
/// <returns></returns>
public virtual DbCommand CreateDbCommand(ISearchExpression searchExpression, IList<ISearchOrder> searchOrders)
{
DbCommand cmd = DbHelper.Instance.Database.DbProviderFactory.CreateCommand();
cmd.CommandType = System.Data.CommandType.Text;
if (searchExpression is QueryExpression)
{
string s = (searchExpression as QueryExpression).Query;
cmd.CommandText = s;
}
else
{
int paramCnt = 0;
if (this.EnablePage && m_dataCanPage)
{
}
else
{
cmd.CommandText = m_selectSql;
// Add Where
if (searchExpression != null)
{
string s = SearchManager.FillDbCommand(searchExpression, cmd.Parameters, false, ref paramCnt, m_selectAsColumns);
if (!string.IsNullOrEmpty(s))
{
cmd.CommandText += " WHERE " + s;
}
}
string groupBy = SearchManager.GetGroupCommand(m_groupBySql);
if (!string.IsNullOrEmpty(groupBy))
{
cmd.CommandText += groupBy;
// Add Having
if (searchExpression != null)
{
string s = SearchManager.FillDbCommand(searchExpression, cmd.Parameters, true, ref paramCnt, m_selectAsColumns);
if (!string.IsNullOrEmpty(s))
{
cmd.CommandText += " HAVING " + s;
}
}
}
cmd.CommandText += SearchManager.GetSqlOrders(searchOrders, false, null);
}
if (paramCnt > 2100)
{
throw new NotSupportedException("您输入的参数过多，系统最多只支持2100个参数！");
}
}
return cmd;
}
/// <summary>
/// Initialize a new instance of the <see cref="LogicalExpression" /> class that
/// combines two other <see cref="ISearchExpression"/>s.
/// </summary>
/// <param name="lhs">The <see cref="ISearchExpression"/> to use in the Left Hand Side.</param>
/// <param name="rhs">The <see cref="ISearchExpression"/> to use in the Right Hand Side.</param>
/// <param name="op"></param>
public LogicalExpression(ISearchExpression lhs, ISearchExpression rhs, LogicalOperator op)
{
_lhs = lhs;
_rhs = rhs;
_op = op;
}
/// <summary>
///
/// </summary>
/// <param name="se"></param>
/// <param name="so"></param>
public DataLoadingEventArgs(ISearchExpression se, IList<ISearchOrder> so)
{
this.SearchExpression = se;
this.SearchOrders = so;
}
internal static ISearchExpression ReplaceSearchExpreesionValues(ISearchExpression se, Dictionary<string, object> dict)
{
Feng.Search.LogicalExpression le = se as Feng.Search.LogicalExpression;
if (le != null)
{
ISearchExpression l = le.LeftHandSide;
l = ReplaceSearchExpreesionValues(l, dict);
ISearchExpression r = le.RightHandSide;
r = ReplaceSearchExpreesionValues(r, dict);
if (l == null)
return r;
else if (r == null)
return l;
else
return new Feng.Search.LogicalExpression(l, r, le.LogicOperator);
}
else
{
Feng.Search.SimpleExpression ce = se as Feng.Search.SimpleExpression;
string s = ce.Values.ToString();
if (s[0] == '%' && s[s.Length - 1] == '%')
{
string s1 = s.Substring(1, s.Length - 2);
if (dict.ContainsKey(s1))
{
ce.Values = dict[s1];
}
else
{
ce = null;
}
}
return ce;
}
}
/// <summary>
/// 把SearchExpression分解成SimpleExpression列表
/// </summary>
/// <param name="searchExpression"></param>
/// <returns></returns>
public static IList<SimpleExpression> GetSimpleExpressions(ISearchExpression searchExpression)
{
List<SimpleExpression> list = new List<SimpleExpression>();
GetSimpleExpressions(searchExpression, list);
return list;
}
/// <summary>
///
/// </summary>
/// <param name="searchExpression"></param>
/// <returns></returns>
public override int GetCount(ISearchExpression searchExpression)
{
string exp = SearchExpression.ToString(searchExpression);
return m_client.GetDataCount(exp);
}
private void FillDbCommand(ISearchExpression condition, DbCommand cmd, ref int paramCnt)
{
SimpleExpression cse = condition as SimpleExpression;
if (cse == null)
{
LogicalExpression l = condition as LogicalExpression;
FillDbCommand(l.LeftHandSide, cmd, ref paramCnt);
FillDbCommand(l.RightHandSide, cmd, ref paramCnt);
}
else
{
string simpleParamName = "@" + cse.FullPropertyName;
string complexParamName = "@" + cse.FullPropertyName + cse.Operator.ToString();
switch (cse.Operator)
{
case SimpleOperator.Any:
case SimpleOperator.EqProperty:
case SimpleOperator.IsNotNull:
case SimpleOperator.IsNull:
case SimpleOperator.NotEq:
case SimpleOperator.NotEqProperty:
case SimpleOperator.Sql:
throw new NotSupportedException(cse.Operator + " is not supported in procedure!");
case SimpleOperator.Ge:
case SimpleOperator.Gt:
case SimpleOperator.Le:
case SimpleOperator.Lt:
cmd.Parameters.Add(DbHelper.Instance.CreateParameter(complexParamName, cse.Values));
break;
case SimpleOperator.Eq:
case SimpleOperator.GInG:
case SimpleOperator.InG:
case SimpleOperator.Like:
cmd.Parameters.Add(DbHelper.Instance.CreateParameter(simpleParamName, cse.Values));
break;
}
paramCnt++;
}
}
/// <summary>
/// 读入数据
/// </summary>
/// <param name="searchExpression"></param>
/// <param name="searchOrders"></param>
protected override void GetDataCount(ISearchExpression searchExpression, IList<ISearchOrder> searchOrders)
{
System.Data.DataTable dt = DbHelper.Instance.ExecuteDataTable(CreateDbCommand(searchExpression, searchOrders));
base.Result = dt.DefaultView;
base.Count = dt.Rows.Count;
}
/// <summary>
/// ���ݲ�ѯ������ѯ����
/// </summary>
/// <param name="searchExpression"></param>
/// <param name="searchOrders"></param>
/// <returns></returns>
public override System.Collections.IEnumerable GetData(ISearchExpression searchExpression, IList<ISearchOrder> searchOrders)
{
string exp = SearchExpression.ToString(searchExpression);
string order = SearchOrder.ToString(searchOrders);
var list = m_client.GetData(exp, order, this.FirstResult, this.MaxResult);
var ret = new List<IDictionary<string, object>>();
foreach (var i in list)
{
ret.Add(Feng.Net.Utils.TypeHelper.ConvertTypeFromWSToDictionary(i));
}
return ret;
}
private ISearchExpression AndIfNecessary(ISearchExpression original, ISearchExpression and)
{
if (original != null)
return SearchExpression.And(original, and);
else
return and;
}
/// <summary>
/// ToString
/// </summary>
/// <param name="searchExpressions"></param>
/// <returns></returns>
public static string ToString(ISearchExpression searchExpressions)
{
if (searchExpressions == null)
{
return string.Empty;
}
else
{
return searchExpressions.ToString();
}
}
internal static void ShowFrom(string actionId, ISearchExpression se, bool asDetailDialog)
{
IDisplayManagerContainer seeForm = null;
ArchiveDetailForm detailForm = null;
ISearchManager sm = null;
if (!asDetailDialog)
{
seeForm = (ServiceProvider.GetService<IApplication>() as IWinFormApplication).ExecuteAction(actionId) as IDisplayManagerContainer;
if (seeForm == null)
{
throw new InvalidOperationException("未能创建目标窗体！");
}
sm = seeForm.DisplayManager.SearchManager;
}
else
{
//detailForm = Feng.Utils.ReflectionHelper.CreateInstanceFromType(Feng.Utils.ReflectionHelper.GetTypeFromName(info.ToDetailForm)) as ArchiveDetailForm;
//if (detailForm == null)
//{
// MessageForm.ShowError("未能创建目标窗体！");
// return;
//}
//detailForm.UpdateContent();
//findWindow = detailForm.DisplayManager.SearchManager;
}
if (sm == null)
{
throw new InvalidOperationException("未能找到目标窗体的查找窗口！");
}
//List<ISearchExpression> findList = new List<ISearchExpression>();
//ISearchExpression findCondition = GetAndFindCondition(selected, 0, toColumns);
//for (int i = 1; i < selected[0].Count; ++i)
//{
// findCondition = new LogicalExpression(findCondition, GetAndFindCondition(selected, i, toColumns), LogicalOperator.Or);
//}
//findList.Add(findCondition);
sm.LoadData(se, null);
if (asDetailDialog)
{
if (detailForm.ControlManager.DisplayManager.Count == 0)
{
ServiceProvider.GetService<IMessageBox>().ShowWarning("未能找到相应记录！");
return;
}
detailForm.ControlManager.DisplayManager.Position = 0;
detailForm.ShowDialog();
detailForm.Dispose();
}
}
/// <summary>
/// ��������
/// </summary>
/// <param name="searchExpression"></param>
/// <param name="searchOrders"></param>
protected override void GetDataCount(ISearchExpression searchExpression, IList<ISearchOrder> searchOrders)
{
base.Result = GetData(searchExpression, searchOrders);
base.Count = GetCount(searchExpression);
}
///// <summary>
///// Constructor
///// </summary>
///// <param name="cmParent"></param>
//public SearchManagerProxyDetailInMaster(IControlManager cmParent)
// : base(cmParent)
//{
//}
/// <summary>
///
/// </summary>
/// <param name="searchExpression"></param>
/// <param name="searchOrders"></param>
/// <param name="parentItem"></param>
/// <returns></returns>
public override System.Collections.IEnumerable GetData(ISearchExpression searchExpression, IList<ISearchOrder> searchOrders, object parentItem)
{
if (parentItem == null)
{
return null;
}
string exp = EntityHelper.ReplaceEntity(m_searchExpression, parentItem);
searchExpression = SearchExpression.And(SearchExpression.Parse(exp), searchExpression);
if (!string.IsNullOrEmpty(m_searchOrder))
{
return m_innerSearchManager.GetData(searchExpression, SearchOrder.Parse(m_searchOrder));
}
else
{
return m_innerSearchManager.GetData(searchExpression, null);
}
}
/// <summary>
///
/// </summary>
/// <param name="searchExpression"></param>
/// <param name="searchOrders"></param>
/// <param name="parentItem"></param>
/// <returns></returns>
public override System.Collections.IEnumerable GetData(ISearchExpression searchExpression, IList<ISearchOrder> searchOrders, object parentItem)
{
if (parentItem == null)
{
return null;
}
SearchHistoryInfo his = this.ParentDisplayManager.SearchManager.GetHistory(0);
if (!string.IsNullOrEmpty(his.Expression))
{
ISearchExpression exp = SearchExpression.Parse(his.Expression);
exp = RemoveParentSelectAsExpression(exp);
searchExpression = SearchExpression.And(searchExpression, exp);
}
foreach (string s in m_groupByColumns)
{
object r = EntityScript.GetPropertyValue(parentItem, s);
ISearchExpression se2;
if (r != null && r != System.DBNull.Value)
{
se2 = SearchExpression.Eq(s, EntityScript.GetPropertyValue(parentItem, s));
}
else
{
se2 = SearchExpression.IsNull(s);
}
searchExpression = SearchExpression.And(searchExpression, se2);
}
this.SetHistory(searchExpression, searchOrders);
return m_innerSearchManager.GetData(searchExpression, searchOrders);
}
/// <summary>
///
/// </summary>
/// <param name="searchExpression"></param>
/// <param name="searchOrders"></param>
public override System.Collections.IEnumerable GetData(ISearchExpression searchExpression, IList<ISearchOrder> searchOrders)
{
object row = this.ParentDisplayManager.CurrentItem;
return GetData(searchExpression, searchOrders, row);
}
//private void ProcessCmd(DbCommand cmd)
//{
// foreach (string s in m_funcParams)
// {
// if (!cmd.Parameters.Contains(s))
// {
// cmd.CommandText = cmd.CommandText.Replace(s, "default");
// }
// else
// {
// // remove like %
// string likeString = cmd.Parameters[s].Value as string;
// if (!string.IsNullOrEmpty(likeString))
// {
// if (likeString[0] == '%' && likeString[likeString.Length - 1] == '%')
// {
// cmd.Parameters[s].Value = likeString.Substring(1, likeString.Length - 2);
// }
// }
// // remove where clause
// int idx = cmd.CommandText.IndexOf("WHERE");
// idx = cmd.CommandText.IndexOf(s, idx);
// int idx2 = idx;
// // jump to "=, >="
// idx2--;
// while (cmd.CommandText[idx2] == ' ')
// idx2--;
// // jump to space
// idx2--;
// while (cmd.CommandText[idx2] != ' ')
// idx2--;
// // jump to propertyName
// idx2--;
// while (cmd.CommandText[idx2] == ' ')
// idx2--;
// // jump to space
// idx2--;
// while (cmd.CommandText[idx2] != ' ')
// idx2--;
// cmd.CommandText = cmd.CommandText.Replace(cmd.CommandText.Substring(idx2 + 1, idx - idx2 - 1 + s.Length), "1 = 1");
// }
// }
//}
private ISearchExpression RemoveFunctionParamSearchExpression(ISearchExpression se, Dictionary<string, object> deletedParam)
{
if (se == null)
return null;
if (se is LogicalExpression)
{
LogicalExpression le = se as LogicalExpression;
ISearchExpression ls = RemoveFunctionParamSearchExpression(le.LeftHandSide, deletedParam);
ISearchExpression rs = RemoveFunctionParamSearchExpression(le.RightHandSide, deletedParam);
switch (le.LogicOperator)
{
case LogicalOperator.And:
return SearchExpression.And(ls, rs);
case LogicalOperator.Or:
return SearchExpression.Or(ls, rs);
case LogicalOperator.Not:
return SearchExpression.Not(ls);
default:
throw new NotSupportedException("Not Supported LogicalOperator!");
}
}
else if (se is SimpleExpression)
{
SimpleExpression cse = se as SimpleExpression;
string paramName = SearchManager.CreateParamName(cse, null);
if (Array.IndexOf(m_funcParams, paramName) != -1)
{
deletedParam[paramName] = cse.Values;
return null;
}
else
{
return cse;
}
}
else
{
return se;
}
}
/// <summary>
///
/// </summary>
/// <param name="hs"></param>
/// <returns></returns>
public static ISearchExpression Not(ISearchExpression hs)
{
return new LogicalExpression(hs, null, LogicalOperator.Not);
}
/// <summary>
///
/// </summary>
/// <param name="searchExpression"></param>
/// <returns></returns>
public override int GetCount(ISearchExpression searchExpression)
{
System.Data.DataTable dt = DbHelper.Instance.ExecuteDataTable(CreateDbCommand(searchExpression, null));
return dt.Rows.Count;
}
/// <summary>
/// 根据查询条件查询数据
/// </summary>
/// <param name="searchExpression"></param>
/// <param name="searchOrders"></param>
/// <returns></returns>
public override System.Collections.IEnumerable GetData(ISearchExpression searchExpression, IList<ISearchOrder> searchOrders)
{
return DbHelper.Instance.ExecuteDataTable(CreateDbCommand(searchExpression, searchOrders)).DefaultView;
}
/// <summary>
/// 根据查询条件读入数据
/// </summary>
/// <param name="searchExpression"></param>
/// <param name="searchOrders"></param>
protected override void GetDataCount(ISearchExpression searchExpression, IList<ISearchOrder> searchOrders)
{
System.Data.DataTable dt = GetData(searchExpression, searchOrders) as System.Data.DataTable;
if (this.EnablePage && m_dataCanPage)
{
base.Count = GetCount(searchExpression);
}
else
{
base.Count = dt.Rows.Count;
}
// 需要分页但数据库读取不能分页的时候，读出全部数据然后选择性返回
if (this.EnablePage && !m_dataCanPage)
{
System.Data.DataTable dt2 = dt.Clone();
for (int i = 0; i < Math.Min(dt.Rows.Count, this.MaxResult); ++i)
{
dt2.ImportRow(dt.Rows[i + this.FirstResult]);
}
base.Result = dt2.DefaultView;
}
else
{
base.Result = dt.DefaultView;
}
}
