Exemple #1
0
        /// <summary>
        /// 根据查询条件创建Criteria
        /// </summary>
        /// <param name="session"></param>
        /// <param name="searchExpression"></param>
        /// <param name="searchOrders"></param>
        /// <param name="hasCollection"></param>
        /// <returns></returns>
        public static NHibernate.ICriteria CreateCriteria(NHibernate.ISession session, ISearchExpression searchExpression,
                                                          IList <ISearchOrder> searchOrders, ref bool hasCollection)
        {
            hasCollection = false;
            int paramCnt = 0;

            NHibernate.ICriteria           criteria = session.CreateCriteria(typeof(T), "Current");
            Dictionary <string, ICriteria> aliases  = new Dictionary <string, ICriteria>();

            aliases.Add("Current", criteria);

            NHibernate.Criterion.ICriterion criterion = GetCriterion(session.SessionFactory, ref criteria, aliases, searchExpression, ref hasCollection, ref paramCnt);
            if (criterion != null)
            {
                criteria.Add(criterion);
            }
            if (paramCnt > 2100)
            {
                throw new NotSupportedException("您输入的参数过多,系统最多只支持2100个参数!");
            }

            if (searchOrders != null)
            {
                foreach (ISearchOrder so in searchOrders)
                {
                    criteria.AddOrder(GetOrder(ref criteria, aliases, so));
                }
            }

            return(aliases["Current"]);
        }
        //TODO: use nhibernate join
        private async void LoadWordsCollection(NHibernate.Criterion.ICriterion expression = null)
        {
            var allWords = new List <Word>();

            WordsCollection.Clear();
            var collection = await WordsService.GetDataAsync <Word>(expression);

            if (collection != null)
            {
                foreach (var item in collection)
                {
                    if (!allWords.Exists(x => x.Id == item.Id))
                    {
                        allWords.Add(item);
                    }
                }
            }
            foreach (var item in allWords)
            {
                WordsCollection.Add(new WordViewModel {
                    WordToDisplay = item
                });
            }
            var alreadyAdded = allWords.Count;

            //only in case of searching it does matter
            if (expression != null)
            {
                var collection2 = await WordsService.GetDataAsync <Translation>(expression);

                if (collection2 != null)
                {
                    foreach (var item in collection2)
                    {
                        foreach (var w in item.WordsStoredIn)
                        {
                            if (!allWords.Exists(x => x.Id == w.Id))
                            {
                                allWords.Add(w);
                            }
                        }
                    }
                }
            }

            foreach (var item in allWords.Skip(alreadyAdded))
            {
                WordsCollection.Add(new WordViewModel {
                    WordToDisplay = item
                });
            }
            allWords = null;
        }
        public static void AddCriteriaExpressions(ICriteria criteria, DataObject objectDefinition, DataFilter dataFilter)
        {
            if (dataFilter != null)
            {
                if (dataFilter.Expressions != null)
                {
                    List <NHibernate.Criterion.ICriterion> criterions = new List <NHibernate.Criterion.ICriterion>();
                    string wildcard = "%";

                    foreach (Expression expression in dataFilter.Expressions)
                    {
                        DataProperty dataProperty = objectDefinition.dataProperties.Find(x => x.propertyName.ToUpper() == expression.PropertyName.ToUpper());

                        if (dataProperty != null)
                        {
                            string propertyName = dataProperty.propertyName;
                            Values valuesStr    = expression.Values;
                            string valueStr     = valuesStr.First();
                            object value        = ConvertValue(valueStr, dataProperty.dataType);

                            NHibernate.Criterion.ICriterion criterion = null;

                            switch (expression.RelationalOperator)
                            {
                            case RelationalOperator.EqualTo:
                                criterion = NHibernate.Criterion.Expression.Eq(propertyName, value);
                                break;

                            case RelationalOperator.NotEqualTo:
                                criterion = NHibernate.Criterion.Expression.Not(NHibernate.Criterion.Expression.Eq(propertyName, value));
                                break;

                            case RelationalOperator.LesserThan:
                                criterion = NHibernate.Criterion.Expression.Lt(propertyName, value);
                                break;

                            case RelationalOperator.LesserThanOrEqual:
                                criterion = NHibernate.Criterion.Expression.Le(propertyName, value);
                                break;

                            case RelationalOperator.GreaterThan:
                                criterion = NHibernate.Criterion.Expression.Gt(propertyName, value);
                                break;

                            case RelationalOperator.GreaterThanOrEqual:
                                criterion = NHibernate.Criterion.Expression.Ge(propertyName, value);
                                break;

                            case RelationalOperator.StartsWith:
                                criterion = NHibernate.Criterion.Expression.Like(propertyName, value + wildcard);
                                break;

                            case RelationalOperator.EndsWith:
                                criterion = NHibernate.Criterion.Expression.Like(propertyName, wildcard + value);
                                break;

                            case RelationalOperator.Contains:
                                criterion = NHibernate.Criterion.Expression.Like(propertyName, wildcard + value + wildcard);
                                break;

//337
                            case RelationalOperator.IsNull:
                                criterion = NHibernate.Criterion.Expression.IsNull(propertyName);
                                break;

                            case RelationalOperator.IsNotNull:
                                criterion = NHibernate.Criterion.Expression.IsNotNull(propertyName);
                                break;
//337


                            case RelationalOperator.In:
                                if (dataProperty.dataType == DataType.String)
                                {
                                    criterion = NHibernate.Criterion.Expression.In(propertyName, valuesStr);
                                }
                                else
                                {
                                    List <object> values = new List <object>();

                                    foreach (string valStr in valuesStr)
                                    {
                                        values.Add(ConvertValue(valStr, dataProperty.dataType));
                                    }

                                    criterion = NHibernate.Criterion.Expression.In(propertyName, values);
                                }
                                break;
                            }


                            criterions.Add(criterion);
                        }
                    }

                    // connect criterions with logical operators
                    //TODO: process grouping
                    if (criterions.Count == 1)
                    {
                        criteria.Add(criterions.First());
                    }
                    else if (criterions.Count > 1)
                    {
                        NHibernate.Criterion.ICriterion lhs = criterions.First();

                        for (int i = 1; i < dataFilter.Expressions.Count; i++)
                        {
                            Expression expression = dataFilter.Expressions[i];

                            if (expression.LogicalOperator != LogicalOperator.None)
                            {
                                NHibernate.Criterion.ICriterion rhs = criterions[i];

                                switch (expression.LogicalOperator)
                                {
                                case LogicalOperator.And:
                                    lhs = NHibernate.Criterion.Expression.And(lhs, rhs);
                                    break;

                                case LogicalOperator.Or:
                                    lhs = NHibernate.Criterion.Expression.Or(lhs, rhs);
                                    break;

                                    //case LogicalOperator.Not:
                                    //  lhs = NHibernate.Criterion.Expression.Not(lhs);
                                    //  break;

                                    //case LogicalOperator.AndNot:
                                    //  lhs = NHibernate.Criterion.Expression.And(lhs, rhs);
                                    //  break;

                                    //case LogicalOperator.OrNot:
                                    //  lhs = NHibernate.Criterion.Expression.Or(lhs, rhs);
                                    //  break;
                                }
                            }
                        }

                        criteria.Add(lhs);
                    }
                }

                if (dataFilter.OrderExpressions != null)
                {
                    foreach (OrderExpression expression in dataFilter.OrderExpressions)
                    {
                        DataProperty dataProperty = objectDefinition.dataProperties.Find(x => x.propertyName.ToUpper() == expression.PropertyName.ToUpper());
                        string       propertyName = dataProperty.propertyName;

                        if (expression.SortOrder == SortOrder.Asc)
                        {
                            criteria.AddOrder(NHibernate.Criterion.Order.Asc(propertyName));
                        }

                        if (expression.SortOrder == SortOrder.Desc)
                        {
                            criteria.AddOrder(NHibernate.Criterion.Order.Desc(propertyName));
                        }
                    }
                }
            }
        }
Exemple #4
0
        public static NHibernateICriterion ToNHibernateCriterion(Dddml.Support.Criterion.ICriterion criterion)
        {
            NHibernateICriterion cr = null;

            if (criterion is SimpleExpression)
            {
                var e = criterion as SimpleExpression;

                if (e.Op.Trim().Equals(Restrictions.OpEq, StringComparison.InvariantCultureIgnoreCase))
                {
                    cr = NHibernateRestrictions.Eq(e.PropertyName, e.Value);
                }
                if (e.Op.Trim().Equals(Restrictions.OpGt, StringComparison.InvariantCultureIgnoreCase))
                {
                    cr = NHibernateRestrictions.Gt(e.PropertyName, e.Value);
                }
                if (e.Op.Trim().Equals(Restrictions.OpLt, StringComparison.InvariantCultureIgnoreCase))
                {
                    cr = NHibernateRestrictions.Lt(e.PropertyName, e.Value);
                }
                if (e.Op.Trim().Equals(Restrictions.OpGe, StringComparison.InvariantCultureIgnoreCase))
                {
                    cr = NHibernateRestrictions.Ge(e.PropertyName, e.Value);
                }
                if (e.Op.Trim().Equals(Restrictions.OpLe, StringComparison.InvariantCultureIgnoreCase))
                {
                    cr = NHibernateRestrictions.Le(e.PropertyName, e.Value);
                }
                if (e.Op.Trim().Equals(Restrictions.OpLike, StringComparison.InvariantCultureIgnoreCase))
                {
                    cr = NHibernateRestrictions.Like(e.PropertyName, e.Value);
                }
            }
            else
            {
                if (criterion is InsensitiveLikeExpression)
                {
                    var e = criterion as InsensitiveLikeExpression; cr = NHibernateRestrictions.InsensitiveLike(e.PropertyName, e.Value);
                }
                if (criterion is InExpression)
                {
                    var e = criterion as InExpression; cr = NHibernateRestrictions.In(e.PropertyName, e.Values);
                }
                if (criterion is NullExpression)
                {
                    var e = criterion as NullExpression; cr = NHibernateRestrictions.IsNull(e.PropertyName);
                }
                if (criterion is NotNullExpression)
                {
                    var e = criterion as NotNullExpression; cr = NHibernateRestrictions.IsNotNull(e.PropertyName);
                }
                if (criterion is BetweenExpression)
                {
                    var e = criterion as BetweenExpression; cr = NHibernateRestrictions.Between(e.PropertyName, e.Lo, e.Hi);
                }
                if (criterion is AndExpression)
                {
                    var e = criterion as AndExpression; cr = NHibernateRestrictions.And(ToNHibernateCriterion(e.LeftHandSide), ToNHibernateCriterion(e.RightHandSide));
                }
                if (criterion is OrExpression)
                {
                    var e = criterion as OrExpression; cr = NHibernateRestrictions.Or(ToNHibernateCriterion(e.LeftHandSide), ToNHibernateCriterion(e.RightHandSide));
                }
                if (criterion is NotExpression)
                {
                    var e = criterion as NotExpression; cr = NHibernateRestrictions.Not(ToNHibernateCriterion(e.Criterion));
                }
                if (criterion is Disjunction)
                {
                    var e = criterion as Disjunction;
                    var j = NHibernateRestrictions.Disjunction();
                    foreach (var c in e.Criteria)
                    {
                        j.Add(ToNHibernateCriterion(c));
                    }
                    cr = j;
                }
                if (criterion is Conjunction)
                {
                    var e = criterion as Conjunction;
                    var j = NHibernateRestrictions.Conjunction();
                    foreach (var c in e.Criteria)
                    {
                        j.Add(ToNHibernateCriterion(c));
                    }
                    cr = j;
                }

                if (criterion is EqPropertyExpression)
                {
                    var e = criterion as EqPropertyExpression; cr = NHibernateRestrictions.EqProperty(e.LhsPropertyName, e.RhsPropertyName);
                }
                if (criterion is GtPropertyExpression)
                {
                    var e = criterion as GtPropertyExpression; cr = NHibernateRestrictions.GtProperty(e.LhsPropertyName, e.RhsPropertyName);
                }
                if (criterion is LtPropertyExpression)
                {
                    var e = criterion as LtPropertyExpression; cr = NHibernateRestrictions.LtProperty(e.LhsPropertyName, e.RhsPropertyName);
                }
                if (criterion is GePropertyExpression)
                {
                    var e = criterion as GePropertyExpression; cr = NHibernateRestrictions.GeProperty(e.LhsPropertyName, e.RhsPropertyName);
                }
                if (criterion is LePropertyExpression)
                {
                    var e = criterion as LePropertyExpression; cr = NHibernateRestrictions.LeProperty(e.LhsPropertyName, e.RhsPropertyName);
                }
            }
            if (cr == null)
            {
                throw new NotSupportedException(String.Format("Not supported criterion. type name: {0}, {1}", criterion.GetType().Name, criterion));
            }
            return(cr);
        }
Exemple #5
0
 /// <summary>
 /// Not implemented
 /// </summary>
 /// <param name="expression">Parameter expression not used</param>
 /// <returns>Operation not implemented</returns>
 public IQueryOver <T, T> Where(NHibernate.Criterion.ICriterion expression)
 {
     throw new NotImplementedException();
 }
Exemple #6
0
 /// <summary>
 /// Not implemented
 /// </summary>
 /// <typeparam name="U">Type parameter not used</typeparam>
 /// <param name="path">Parameter path not used</param>
 /// <param name="alias">Parameter alias not used</param>
 /// <param name="joinType">Parameter joinType not used</param>
 /// <param name="withClause">Parameter withClause not used</param>
 /// <returns>Operation not implemented</returns>
 public IQueryOver <T, U> JoinQueryOver <U>(System.Linq.Expressions.Expression <Func <T, U> > path, System.Linq.Expressions.Expression <Func <U> > alias, NHibernate.SqlCommand.JoinType joinType, NHibernate.Criterion.ICriterion withClause)
 {
     throw new NotImplementedException();
 }
Exemple #7
0
        // 如果是Component,则用入款金额.数额,不需要用:,不需要创建子Criteria。
        private static NHibernate.Criterion.ICriterion GetCriterion(ISessionFactory sessionFactory, ref ICriteria originalCriteria,
                                                                    Dictionary <string, ICriteria> aliases,
                                                                    ISearchExpression se, ref bool hasCollection, ref int paramCnt)
        {
            if (se == null)
            {
                return(null);
            }
            if (se is Feng.Search.QueryExpression)
            {
                return(null);
            }

            SimpleExpression cse = se as SimpleExpression;

            if (cse == null)
            {
                LogicalExpression le = se as LogicalExpression;

                NHibernate.Criterion.ICriterion left  = GetCriterion(sessionFactory, ref originalCriteria, aliases, le.LeftHandSide, ref hasCollection, ref paramCnt);
                NHibernate.Criterion.ICriterion right = GetCriterion(sessionFactory, ref originalCriteria, aliases, le.RightHandSide, ref hasCollection, ref paramCnt);

                switch (le.LogicOperator)
                {
                case LogicalOperator.And:
                    return(NHibernate.Criterion.Expression.And(left, right));

                case LogicalOperator.Or:
                    return(NHibernate.Criterion.Expression.Or(left, right));

                case LogicalOperator.Not:
                    return(NHibernate.Criterion.Expression.Not(left));

                default:
                    System.Diagnostics.Debug.Assert(false, "Not supported LogicOperator");
                    return(null);
                }
            }
            else
            {
                // No PropertyName Process
                if (cse.Operator == SimpleOperator.Sql)
                {
                    return(NHibernate.Criterion.Expression.Sql(cse.FullPropertyName));
                }

                string propertyName = TryCreateCriteria(cse.FullPropertyName, ref originalCriteria, aliases);

                if (!string.IsNullOrEmpty(cse.FullPropertyName))
                {
                    // Convert Data to dest type
                    bool hasC;
                    Type destType;
                    if (cse.Operator != SimpleOperator.EqProperty)
                    {
                        destType       = NHibernateHelper.GetPropertyType(sessionFactory, typeof(T), cse.FullPropertyName, out hasC);
                        hasCollection |= hasC;
                    }
                    else
                    {
                        destType = typeof(string);
                    }

                    IList array = cse.Values as IList;
                    if (array != null)
                    {
                        for (int i = 0; i < array.Count; ++i)
                        {
                            if (destType != array[i].GetType())
                            {
                                array[i] = ConvertHelper.ChangeType(array[i], destType);
                            }
                        }

                        paramCnt += array.Count;
                    }
                    else
                    {
                        if (cse.Values != null)
                        {
                            if (destType != cse.Values.GetType())
                            {
                                cse.Values = ConvertHelper.ChangeType(cse.Values, destType);
                            }
                        }

                        paramCnt++;
                    }
                }

                switch (cse.Operator)
                {
                case SimpleOperator.Eq:
                    return(NHibernate.Criterion.Expression.Eq(propertyName, cse.Values));

                case SimpleOperator.NotEq:
                    return(NHibernate.Criterion.Expression.Not(NHibernate.Criterion.Expression.Eq(propertyName, cse.Values)));

                case SimpleOperator.EqProperty:
                {
                    if (cse.Values == null)
                    {
                        throw new ArgumentException("EqProperty's Value should not be null!", "cse");
                    }
                    string toPropertyName = TryCreateCriteria(cse.Values.ToString(), ref originalCriteria, aliases);
                    return(NHibernate.Criterion.Expression.EqProperty(propertyName, toPropertyName));
                }

                case SimpleOperator.Like:
                {
                    int?propertyLength = NHibernateHelper.GetPropertyLength(sessionFactory, typeof(T), cse.FullPropertyName);
                    return(GetLikeCriterion(propertyName, cse.Values, propertyLength));
                }

                case SimpleOperator.InG:
                    return(NHibernate.Criterion.Expression.In(propertyName, cse.Values as IList));

                case SimpleOperator.IsNotNull:
                    return(NHibernate.Criterion.Expression.IsNotNull(propertyName));

                case SimpleOperator.IsNull:
                    return(NHibernate.Criterion.Expression.IsNull(propertyName));

                case SimpleOperator.Gt:
                    return(NHibernate.Criterion.Expression.Gt(propertyName, cse.Values));

                case SimpleOperator.Lt:
                    return(NHibernate.Criterion.Expression.Lt(propertyName, cse.Values));

                case SimpleOperator.Ge:
                    return(NHibernate.Criterion.Expression.Ge(propertyName, cse.Values));

                case SimpleOperator.Le:
                    return(NHibernate.Criterion.Expression.Le(propertyName, cse.Values));

                case SimpleOperator.GInG:
                {
                    int?propertyLength = NHibernateHelper.GetPropertyLength(sessionFactory, typeof(T), cse.FullPropertyName);

                    IList data = cse.Values as IList;
                    // 通过查询控件控制
                    // 当用于客户用途查找类型时,只能Like
                    //if (data.Count <= 1)
                    {
                        NHibernate.Criterion.ICriterion criterion = GetLikeCriterion(propertyName, data[0], propertyLength);
                        for (int i = 1; i < data.Count; ++i)
                        {
                            criterion = NHibernate.Criterion.Expression.Or(criterion, GetLikeCriterion(propertyName, data[i], propertyLength));
                        }
                        return(criterion);
                    }
                    //// 当多行时,不在模糊查找
                    //else
                    //{
                    //    return NHibernate.Criterion.Expression.In(propertyName, data);
                    //}
                }

                case SimpleOperator.Any:
                    return(NHibernate.Criterion.Expression.EqProperty(propertyName, propertyName));

                case SimpleOperator.Sql:
                    return(NHibernate.Criterion.Expression.Sql(cse.FullPropertyName));

                default:
                    System.Diagnostics.Debug.Assert(false, "Not supported SimpleOperator");
                    return(null);
                }
            }
        }