private IPredicate GetMemberWeiXinsCondition(int?id, string memberUUID, string weiXinOpenId, string phoneNumber, string name)
        {
            List <IPredicate> predicates = new List <IPredicate>();

            #region 基本条件
            predicates.Add(PredicateFactory.Equal <CMemberWeiXinPO>(t => t.IsDelete, false));
            if (id.HasValue)
            {
                predicates.Add(PredicateFactory.Equal <CMemberWeiXinPO>(t => t.Id, id.Value));
            }
            if (!string.IsNullOrWhiteSpace(memberUUID))
            {
                predicates.Add(PredicateFactory.Equal <CMemberWeiXinPO>(t => t.MemberUUID, memberUUID));
            }
            if (!string.IsNullOrWhiteSpace(weiXinOpenId))
            {
                predicates.Add(PredicateFactory.Equal <CMemberWeiXinPO>(t => t.WeiXinOpenId, weiXinOpenId));
            }
            if (!string.IsNullOrWhiteSpace(phoneNumber))
            {
                predicates.Add(PredicateFactory.Like <CMemberWeiXinPO>(t => t.PhoneNumber, "%" + phoneNumber.ToSafeSQLLike() + "%"));
            }
            if (!string.IsNullOrWhiteSpace(name))
            {
                predicates.Add(PredicateFactory.Like <CMemberWeiXinPO>(t => t.Name, "%" + name.ToSafeSQLLike() + "%"));
            }
            #endregion

            #region 数量条件
            #endregion
            return(PredicateFactory.And(predicates.ToArray()));
        }
Example #2
0
        private IPredicate GetOrderCommodityRelationsCondition(int?id, List <string> orderUUID, List <string> commodityWithPropertyUUID, List <string> commodityUUID)
        {
            List <IPredicate> predicates = new List <IPredicate>();

            #region 基本条件
            predicates.Add(PredicateFactory.Equal <COrderCommodityRelationPO>(t => t.IsDelete, false));
            if (id.HasValue)
            {
                predicates.Add(PredicateFactory.Equal <COrderCommodityRelationPO>(t => t.Id, id.Value));
            }
            if (orderUUID != null && orderUUID.Count > 0)
            {
                predicates.Add(PredicateFactory.In <COrderCommodityRelationPO>(t => t.OrderUUID, orderUUID.ToArray()));
            }
            if (commodityWithPropertyUUID != null && commodityWithPropertyUUID.Count > 0)
            {
                predicates.Add(PredicateFactory.In <COrderCommodityRelationPO>(t => t.CommodityWithPropertyUUID, commodityWithPropertyUUID.ToArray()));
            }
            if (commodityUUID != null && commodityUUID.Count > 0)
            {
                predicates.Add(PredicateFactory.In <COrderCommodityRelationPO>(t => t.CommodityUUID, commodityUUID.ToArray()));
            }
            #endregion

            #region 数量条件
            #endregion
            return(PredicateFactory.And(predicates.ToArray()));
        }
Example #3
0
        public void Compare_NumericVariablePartOfDictionary_PointlessVariableIsNotEvaluated()
        {
            var variableUsed = new Mock <ITestVariable>();

            variableUsed.Setup(v => v.GetValue()).Returns(10);
            var variablePointless = new Mock <ITestVariable>();

            variablePointless.Setup(v => v.GetValue()).Returns(0);
            var variables = new Dictionary <string, ITestVariable>()
            {
                { "var", variableUsed.Object }, { "x", variablePointless.Object }
            };

            var info = new Mock <IPredicateInfo>();

            info.SetupGet(i => i.ColumnType).Returns(ColumnType.Numeric);
            info.SetupGet(i => i.ComparerType).Returns(ComparerType.LessThan);
            info.As <IReferencePredicateInfo>().SetupGet(p => p.Reference).Returns("@var");

            var factory   = new PredicateFactory();
            var predicate = factory.Instantiate(info.Object, variables);

            Assert.That(predicate.Execute(9), Is.True);
            Assert.That(predicate.Execute(11), Is.False);
            variablePointless.Verify(x => x.GetValue(), Times.Never);
        }
        private IPredicate GetManagersCondition(int?id, string name, string passWord, int?userLevel)
        {
            List <IPredicate> predicates = new List <IPredicate>();

            #region 基本条件
            predicates.Add(PredicateFactory.Equal <CManagerPO>(t => t.IsDelete, false));
            if (id.HasValue)
            {
                predicates.Add(PredicateFactory.Equal <CManagerPO>(t => t.Id, id.Value));
            }
            if (!string.IsNullOrWhiteSpace(name))
            {
                predicates.Add(PredicateFactory.Equal <CManagerPO>(t => t.Name, name));
            }
            if (!string.IsNullOrWhiteSpace(passWord))
            {
                predicates.Add(PredicateFactory.Equal <CManagerPO>(t => t.PassWord, passWord));
            }
            if (userLevel.HasValue)
            {
                predicates.Add(PredicateFactory.Equal <CManagerPO>(t => t.UserLevel, userLevel.Value));
            }
            #endregion

            #region 数量条件
            #endregion
            return(PredicateFactory.And(predicates.ToArray()));
        }
Example #5
0
 internal PredicateRule(string pattern, PredicateFactory factory, TripletParser owner)
 {
     _pattern = pattern;
     _owner = owner;
     _factory = factory;
     _constraints = getPredicateConstraints(pattern);
 }
        private IPredicate GetCResCoordinateCondition(int?id, string resUUID, List <decimal> longitude, List <decimal> latitude, List <string> markUUID)
        {
            List <IPredicate> predicates = new List <IPredicate>();

            #region 基本条件
            predicates.Add(PredicateFactory.Equal <CResCoordinatePO>(t => t.IsDelete, false));
            if (id.HasValue)
            {
                predicates.Add(PredicateFactory.Equal <CResCoordinatePO>(t => t.Id, id));
            }
            if (!string.IsNullOrWhiteSpace(resUUID))
            {
                predicates.Add(PredicateFactory.Equal <CResCoordinatePO>(t => t.ResUUID, resUUID));
            }
            if (longitude != null && longitude.Count > 0)
            {
                predicates.Add(PredicateFactory.In <CResCoordinatePO>(t => t.Longitude, longitude.ToArray()));
            }
            if (latitude != null && latitude.Count > 0)
            {
                predicates.Add(PredicateFactory.In <CResCoordinatePO>(t => t.Latitude, latitude.ToArray()));
            }
            if (markUUID != null && markUUID.Count > 0)
            {
                predicates.Add(PredicateFactory.In <CResCoordinatePO>(t => t.MarkUUID, markUUID.ToArray()));
            }
            #endregion

            #region 数量条件
            #endregion
            return(PredicateFactory.And(predicates.ToArray()));
        }
Example #7
0
        public BasePredicateFilter Instantiate(IEnumerable <IColumnAlias> aliases, IEnumerable <IColumnExpression> expressions, CombinationOperator combinationOperator, IEnumerable <IPredicateInfo> predicateInfos)
        {
            var predications = new List <Predication>();

            var factory = new PredicateFactory();

            foreach (var predicateInfo in predicateInfos)
            {
                if (string.IsNullOrEmpty(predicateInfo.Operand))
                {
                    throw new ArgumentException("You must specify an operand for a predicate. The operand is the column or alias or expression on which the predicate will be evaluated.");
                }

                var predicate = factory.Instantiate(predicateInfo);
                predications.Add(new Predication(predicate, predicateInfo.Operand));
            }

            switch (combinationOperator)
            {
            case CombinationOperator.Or:
                return(new OrCombinationPredicateFilter(aliases, expressions, predications));

            case CombinationOperator.XOr:
                return(new XOrCombinationPredicateFilter(aliases, expressions, predications));

            case CombinationOperator.And:
                return(new AndCombinationPredicateFilter(aliases, expressions, predications));

            default:
                throw new ArgumentOutOfRangeException(nameof(combinationOperator));
            }
        }
Example #8
0
        private IPredicate GetBusinessHourWeekCondition(int?id, List <string> uUID, List <string> resUUID, List <string> typeUUID, List <int> states)
        {
            List <IPredicate> predicates = new List <IPredicate>();

            #region 基本条件
            predicates.Add(PredicateFactory.Equal <BusinessHourWeekPO>(t => t.Deleted, false));
            if (id.HasValue)
            {
                predicates.Add(PredicateFactory.Equal <BusinessHourWeekPO>(t => t.Id, id));
            }
            if (uUID != null && uUID.Count > 0)
            {
                predicates.Add(PredicateFactory.In <BusinessHourWeekPO>(t => t.UUID, uUID.ToArray()));
            }
            if (resUUID != null && resUUID.Count > 0)
            {
                predicates.Add(PredicateFactory.In <BusinessHourWeekPO>(t => t.ResUUID, resUUID.ToArray()));
            }
            if (typeUUID != null && typeUUID.Count > 0)
            {
                predicates.Add(PredicateFactory.In <BusinessHourWeekPO>(t => t.TypeUUID, typeUUID.ToArray()));
            }
            if (states != null && states.Count > 0)
            {
                predicates.Add(PredicateFactory.In <BusinessHourWeekPO>(t => t.State, states.ToArray()));
            }
            #endregion

            #region 数量条件
            #endregion
            return(PredicateFactory.And(predicates.ToArray()));
        }
Example #9
0
        private IPredicate GetCCommoditysCondition(int?id, string resUUID, string commodityUUID, List <string> commodityCategoryUUIDs, List <int> states, string name)
        {
            List <IPredicate> predicates = new List <IPredicate>();

            predicates.Add(PredicateFactory.Equal <CCommodityPropertyPO>(t => t.IsDelete, false));

            if (id.HasValue)
            {
                predicates.Add(PredicateFactory.Equal <CCommodityPO>(t => t.Id, id.Value));
            }
            if (!string.IsNullOrWhiteSpace(resUUID))
            {
                predicates.Add(PredicateFactory.Equal <CCommodityPO>(t => t.ResUUID, resUUID));
            }
            if (!string.IsNullOrWhiteSpace(commodityUUID))
            {
                predicates.Add(PredicateFactory.Equal <CCommodityPO>(t => t.CommodityUUID, commodityUUID));
            }
            if ((commodityCategoryUUIDs != null) && (commodityCategoryUUIDs.Count > 0))
            {
                predicates.Add(PredicateFactory.In <CCommodityPO>(t => t.CommodityCategoryUUID, commodityCategoryUUIDs.ToArray()));
            }
            if ((states != null) && (states.Count > 0))
            {
                predicates.Add(PredicateFactory.In <CCommodityPO>(t => t.State, states.ToArray()));
            }
            if (!string.IsNullOrWhiteSpace(name))
            {
                IPredicate[] predicateArray1 = new IPredicate[2];
                predicateArray1[0] = PredicateFactory.Like <CCommodityPO>(t => t.ChineseName, "%" + name.ToSafeSQLLike() + "%");
                predicateArray1[1] = PredicateFactory.Like <CCommodityPO>(t => t.EnglishName, "%" + name.ToSafeSQLLike() + "%");
                predicates.Add(PredicateFactory.Or(predicateArray1));
            }
            return(PredicateFactory.And(predicates.ToArray()));
        }
        private IPredicate GetCommodityPropertysCondition(List <int> id, string resUUID, string commodityPropertyUUID, List <string> commodityUUIDs, List <string> propertyCategoryUUIDs)
        {
            List <IPredicate> predicates = new List <IPredicate>();

            #region 基本条件
            predicates.Add(PredicateFactory.Equal <CCommodityPropertyPO>(t => t.IsDelete, false));
            if (id != null && id.Count > 0)
            {
                predicates.Add(PredicateFactory.In <CCommodityPropertyPO>(t => t.Id, id.ToArray()));
            }
            if (!string.IsNullOrWhiteSpace(resUUID))
            {
                predicates.Add(PredicateFactory.Equal <CCommodityPropertyPO>(t => t.ResUUID, resUUID));
            }
            if (!string.IsNullOrWhiteSpace(commodityPropertyUUID))
            {
                predicates.Add(PredicateFactory.Equal <CCommodityPropertyPO>(t => t.CommodityPropertyUUID, commodityPropertyUUID));
            }

            if (commodityUUIDs != null && commodityUUIDs.Count > 0)
            {
                predicates.Add(PredicateFactory.In <CCommodityPropertyPO>(t => t.CommodityUUID, commodityUUIDs.ToArray()));
            }

            if (propertyCategoryUUIDs != null && propertyCategoryUUIDs.Count > 0)
            {
                predicates.Add(PredicateFactory.In <CCommodityPropertyPO>(t => t.PropertyCategoryUUID, propertyCategoryUUIDs.ToArray()));
            }
            #endregion

            #region 数量条件
            #endregion
            return(PredicateFactory.And(predicates.ToArray()));
        }
Example #11
0
        private IPredicate GetCDistributionManagerCondition(int?id, string name, string passWord, int?userLevel, List <string> mobile)
        {
            List <IPredicate> predicates = new List <IPredicate>();

            #region 基本条件
            if (id.HasValue)
            {
                predicates.Add(PredicateFactory.Equal <CDistributionManagerPO>(t => t.Id, id));
            }
            if (!string.IsNullOrWhiteSpace(name))
            {
                predicates.Add(PredicateFactory.Equal <CDistributionManagerPO>(t => t.Name, name));
            }
            if (!string.IsNullOrWhiteSpace(passWord))
            {
                predicates.Add(PredicateFactory.Equal <CDistributionManagerPO>(t => t.PassWord, passWord));
            }
            if (userLevel.HasValue)
            {
                predicates.Add(PredicateFactory.Equal <CDistributionManagerPO>(t => t.UserLevel, userLevel));
            }
            if (mobile != null && mobile.Count > 0)
            {
                predicates.Add(PredicateFactory.In <CDistributionManagerPO>(t => t.Mobile, mobile.ToArray()));
            }
            #endregion

            #region 数量条件
            #endregion
            return(PredicateFactory.And(predicates.ToArray()));
        }
Example #12
0
        public Core.Data.QueryResult <CCouponPO> GetCoupons(int?id, string couponUUID, List <int> couponType, List <int> preferentialType, List <int> state, string resUUID, DateTime?ordrTime, int startIndex, int count)
        {
            Sort       sort      = PredicateFactory.Sort("CreateTime", "desc");
            IPredicate predicate = this.GetCouponsCondition(id, couponUUID, couponType, preferentialType, state, resUUID, ordrTime);

            ISort[] sorts = new ISort[] { sort };
            return(CCouponPOManager.Instance.GetCouponWithTotalCountByPredicate(predicate, startIndex, count, sorts));
        }
        public Core.Data.QueryResult <CMemberWeiXinPO> GetMemberWeiXins(int?id, string memberUUID, string weiXinOpenId, string phoneNumber, string name, int startIndex, int count)
        {
            Sort       sort      = PredicateFactory.Sort("CreateTime", "desc");;
            IPredicate predicate = this.GetMemberWeiXinsCondition(id, memberUUID, weiXinOpenId, phoneNumber, name);

            Core.Data.QueryResult <CMemberWeiXinPO> resultRest = CMemberWeiXinPOManager.Instance.GetMemberWeiXinWithTotalCountByPredicate(predicate, startIndex, count, sort);
            return(resultRest);
        }
Example #14
0
        public Core.Data.QueryResult <CCommodityCategoryPO> GetCommodityCategorys(string resUUID, List <string> commodityCategoryUUIDs, int startIndex, int count)
        {
            Sort       sort      = PredicateFactory.Sort("Sort", "desc");
            IPredicate predicate = this.GetCommodityCategorysCondition(resUUID, commodityCategoryUUIDs);

            ISort[] sorts = new ISort[] { sort };
            return(CCommodityCategoryPOManager.Instance.GetCommodityCategoryWithTotalCountByPredicate(predicate, startIndex, count, sorts));
        }
        public Core.Data.QueryResult <CResCoordinatePO> GetCResCoordinate(int?id, string resUUID, List <decimal> longitude, List <decimal> latitude, List <string> markUUID, int startIndex, int count)
        {
            IPredicate predicate = this.GetCResCoordinateCondition(id, resUUID, longitude, latitude, markUUID);
            Sort       sort      = PredicateFactory.Sort("Id", "asc");

            Core.Data.QueryResult <CResCoordinatePO> resultRest = CResCoordinatePOManager.Instance.GetCResCoordinateWithTotalCountByPredicate(predicate, startIndex, count, sort);
            return(resultRest);
        }
        public Core.Data.QueryResult <CCommodityPropertyPO> GetCommodityPropertys(List <int> id, string resUUID, string commodityPropertyUUID, List <string> commodityUUIDs, List <string> propertyCategoryUUIDs, int startIndex, int count)
        {
            Sort sort = PredicateFactory.Sort("Sort", "desc");;

            IPredicate predicate = this.GetCommodityPropertysCondition(id, resUUID, commodityPropertyUUID, commodityUUIDs, propertyCategoryUUIDs);

            Core.Data.QueryResult <CCommodityPropertyPO> resultRest = CCommodityPropertyPOManager.Instance.GetCommodityPropertyWithTotalCountByPredicate(predicate, startIndex, count, sort);
            return(resultRest);
        }
Example #17
0
        // Token: 0x060001CF RID: 463 RVA: 0x0000B738 File Offset: 0x00009938
        private async void saveRDPToolStripMenuItem_Click(object sender, EventArgs e)
        {
            try
            {
                if (this.totalWinStore.Text != "0")
                {
                    PredicateFactory <string, AbstractLogProfile> predicateFactory = PredicateFactory <string, AbstractLogProfile> .Create();

                    predicateFactory.Predicates.Add(new GrandStealLogProfile(), delegate(string x)
                    {
                        string[] array = new DirectoryInfo(x).Name.Split(new string[]
                        {
                            " "
                        }, StringSplitOptions.None);
                        return(array.Length == 2 && (array[0].Contains("[") && array[0].Contains("]") && array[1].Contains("[")) && array[1].Contains("]"));
                    });
                    ParalleledLogProfile engine = new ParalleledLogProfile(this.ViewModel.LogsVM.PathsToLogs.ClientsWithRDP)
                    {
                        HandlerMap = predicateFactory
                    };
                    LogProfileController          controller = new LogProfileController(engine);
                    IEnumerable <AbstractAccount> enumerable = (await Task.Factory.StartNew <IEnumerable <GrandStealLogProfile> >(() => from x in controller.Load()
                                                                                                                                  select x as GrandStealLogProfile)).SelectMany((GrandStealLogProfile x) => x.RDPS) ?? new List <AbstractAccount>();
                    string text = "RDP_" + DateTime.Now.ToString("O").Replace(':', '_') + ".txt";
                    foreach (AbstractAccount abstractAccount in enumerable)
                    {
                        if (abstractAccount.Password != "NOT SAVED")
                        {
                            File.AppendAllText(text, string.Concat(new string[]
                            {
                                abstractAccount.URL,
                                " ",
                                abstractAccount.Login,
                                " ",
                                abstractAccount.Password,
                                Environment.NewLine
                            }));
                        }
                    }
                    if (enumerable.Any <AbstractAccount>())
                    {
                        if (File.Exists(text))
                        {
                            Process.Start(text);
                        }
                        else
                        {
                            MessageBox.Show("RDPs with saved password not found");
                        }
                    }
                }
            }
            catch (Exception arg)
            {
                MessageBox.Show("Ошибка: " + arg);
            }
        }
Example #18
0
        protected virtual bool RowCompare(ScoredObject oldObj, ScoredObject newObj)
        {
            var info          = new PredicateInfo();
            var factory       = new PredicateFactory();
            var predicateInfo = BuildPredicateInfo(oldObj.Score);
            var predicate     = factory.Instantiate(predicateInfo);

            return(predicate.Execute(newObj.Score));
        }
        private IPredicate GetCCashCouponDetailCondition(int?id, List <int> assetProperty, List <int> memberWeiXinId, List <int> useState, List <int> assetStatus, string assetName, DateTime?validStartTime, DateTime?validEndTime, decimal?saleAmount, DateTime?saleStartTime, DateTime?saleEndTime)
        {
            List <IPredicate> predicates = new List <IPredicate>();

            #region 基本条件
            if (id.HasValue)
            {
                predicates.Add(PredicateFactory.Equal <CCashCouponDetailPO>(t => t.Id, id));
            }
            if (assetProperty != null && assetProperty.Count > 0)
            {
                predicates.Add(PredicateFactory.In <CCashCouponDetailPO>(t => t.AssetProperty, assetProperty.ToArray()));
            }
            if (memberWeiXinId != null && memberWeiXinId.Count > 0)
            {
                predicates.Add(PredicateFactory.In <CCashCouponDetailPO>(t => t.MemberWeiXinId, memberWeiXinId.ToArray()));
            }

            if (useState != null && useState.Count > 0)
            {
                predicates.Add(PredicateFactory.In <CCashCouponDetailPO>(t => t.UseState, useState.ToArray()));
            }
            if (assetStatus != null && assetStatus.Count > 0)
            {
                predicates.Add(PredicateFactory.In <CCashCouponDetailPO>(t => t.AssetStatus, assetStatus.ToArray()));
            }

            if (!string.IsNullOrWhiteSpace(assetName))
            {
                predicates.Add(PredicateFactory.Equal <CCashCouponDetailPO>(t => t.AssetName, assetName));
            }
            if (validStartTime.HasValue)
            {
                predicates.Add(PredicateFactory.Equal <CCashCouponDetailPO>(t => t.ValidStartTime, validStartTime));
            }
            if (validEndTime.HasValue)
            {
                predicates.Add(PredicateFactory.Equal <CCashCouponDetailPO>(t => t.ValidEndTime, validEndTime));
            }
            if (saleAmount.HasValue)
            {
                predicates.Add(PredicateFactory.Equal <CCashCouponDetailPO>(t => t.SaleAmount, saleAmount));
            }
            if (saleStartTime.HasValue)
            {
                predicates.Add(PredicateFactory.Equal <CCashCouponDetailPO>(t => t.SaleStartTime, saleStartTime));
            }
            if (saleEndTime.HasValue)
            {
                predicates.Add(PredicateFactory.Equal <CCashCouponDetailPO>(t => t.SaleEndTime, saleEndTime));
            }
            #endregion

            #region 数量条件
            #endregion
            return(PredicateFactory.And(predicates.ToArray()));
        }
        public PredicateFilter Instantiate(IEnumerable <IColumnAlias> aliases, IEnumerable <IColumnExpression> expressions, IPredicateInfo predicateInfo)
        {
            var factory   = new PredicateFactory();
            var predicate = factory.Get(predicateInfo);

            var pf = new PredicateFilter(aliases, expressions, predicateInfo.Name, predicate.Apply, predicate.ToString);

            return(pf);
        }
Example #21
0
        public BaseConverter(CultureInfo cultureInfo, object defaultValue)
        {
            var info             = GetPredicateArgs(cultureInfo);
            var predicateFactory = new PredicateFactory();

            predicate = predicateFactory.Instantiate(info);

            DefaultValue     = defaultValue;
            this.cultureInfo = cultureInfo;
        }
Example #22
0
 public CDistributionManagerPO[] GetAll()
 {
     using (IEntityContext entityContext = CDistributionManagerPOManager.Instance.CreateEntityContext())
     {
         List <IPredicate> predicates = new List <Core.Data.IPredicate>();
         predicates.Add(PredicateFactory.Equal <CDistributionManagerPO>(o => o.IsDelete, false));
         IPredicate predicate = PredicateFactory.And(predicates.ToArray());
         return(entityContext.Find <CDistributionManagerPO>(predicate));
     }
 }
Example #23
0
        public void Compare_Boolean_ThrowsArgumentException(ComparerType comparerType)
        {
            var info = Mock.Of <IPredicateInfo>(
                i => i.ColumnType == ColumnType.Boolean &&
                i.ComparerType == comparerType
                );

            var factory = new PredicateFactory();

            Assert.Throws <ArgumentException>(delegate { factory.Get(info); });
        }
Example #24
0
        public void Compare_Boolean_ThrowsArgumentException(ComparerType comparerType)
        {
            var info = Mock.Of <PredicateArgs>(
                i => i.ColumnType == ColumnType.Boolean &&
                i.ComparerType == comparerType
                );

            var factory = new PredicateFactory();

            Assert.Throws <ArgumentOutOfRangeException>(delegate { factory.Instantiate(info); });
        }
        public void GetPredicateShouldReturnNullIfFilterIsNull()
        {
            // Arrange
            var predicateFactory = new PredicateFactory(_providersMock.Object);

            // Act
            var predicate = predicateFactory.GetPredicate <TestFilter, TestData>(null);

            // Assert
            predicate.Should().BeNull();
        }
        public void Compare_NotNullDateTime_Failure()
        {
            var info = Mock.Of <IPredicateInfo>(
                i => i.ColumnType == ColumnType.DateTime &&
                i.ComparerType == ComparerType.Null
                );

            var factory  = new PredicateFactory();
            var comparer = factory.Get(info);

            Assert.That(comparer.Apply(new DateTime(2015, 10, 1)), Is.False);
        }
        public void Apply_NullDateTime_Success()
        {
            var info = Mock.Of <IPredicateInfo>(
                i => i.ColumnType == ColumnType.DateTime &&
                i.ComparerType == ComparerType.Null
                );

            var factory  = new PredicateFactory();
            var comparer = factory.Get(info);

            Assert.That(comparer.Apply(null), Is.True);
        }
        public void Compare_Numeric_Result(ComparerType comparerType, object x, bool result)
        {
            var info = Mock.Of <IPredicateInfo>(
                i => i.ColumnType == ColumnType.Numeric &&
                i.ComparerType == comparerType
                );

            var factory  = new PredicateFactory();
            var comparer = factory.Get(info);

            Assert.That(comparer.Apply(x), Is.EqualTo(result));
        }
        public void Apply_Text_Failure(ComparerType comparerType, object x)
        {
            var info = Mock.Of <IPredicateInfo>(
                i => i.ColumnType == ColumnType.Text &&
                i.ComparerType == comparerType
                );

            var factory  = new PredicateFactory();
            var comparer = factory.Get(info);

            Assert.That(comparer.Apply(x), Is.False);
        }
        public void Compare_DateTime_Result(ComparerType comparerType, int hours, int minutes, int seconds, bool result)
        {
            var info = Mock.Of <IPredicateInfo>(
                i => i.ColumnType == ColumnType.DateTime &&
                i.ComparerType == comparerType
                );

            var factory  = new PredicateFactory();
            var comparer = factory.Get(info);

            Assert.That(comparer.Apply(new DateTime(2015, 10, 1, hours, minutes, seconds)), Is.EqualTo(result));
        }
Example #31
0
        public void Compare_DateTime_Success(ComparerType comparerType, int x, int y)
        {
            var info = Mock.Of <IPredicateInfo>(
                i => i.ColumnType == ColumnType.DateTime &&
                i.ComparerType == comparerType
                );

            var factory  = new PredicateFactory();
            var comparer = factory.Get(info);

            Assert.That(comparer.Compare(new DateTime(2015, x, 1), new DateTime(2015, y, 1)), Is.True);
        }
Example #32
0
        static void Test(Database db)
        {
            const string TABLE = "table";
            const string COLUMN = "column";
            const string COLUMN2 = "column2";
            const string COLUMN3 = "column3";
            const string COLUMN4 = "int_column";
            const string COLUMN5 = "code";

            const string msg = "ON222DT29102011T174217P0Z222";

            const string message2 = "выаыаваыва";

            using (var tx = db.Session.BeginTransaction())
            using (var table = db.OpenTable(TABLE))
            using (var cursor = table.OpenPrimaryCursor())
            {
                const string message = "Hello world";
                const string msg3 = "msg3";

                var column1 = table.GetColumn<string>(COLUMN);
                var column2 = table.GetColumn<string>(COLUMN2);
                var column3 = table.GetColumn<string>(COLUMN3);
                var column4 = table.GetColumn<int>(COLUMN4);
                var column5 = table.GetColumn(COLUMN5);

                using (var ins = cursor.AddRow())
                {
                    ins.SetValue(column1, message);
                    ins.SetValue(column2, message2);
                    ins.SetValue(column3, msg3);
                    ins.SetValue(column4, 1);
                    ins.SetValue(column5, msg);
                    ins.Save();
                }

                using (var ins = cursor.AddRow())
                {
                    ins.SetValue(column1, msg3);
                    ins.SetValue(column2, message2);
                    ins.SetValue(column3, msg3);
                    ins.SetValue(column4, 4);
                    ins.SetValue(column5, msg);
                    ins.Save();
                }

                tx.Commit();
            }

            Console.WriteLine(COLUMN + " : " + COLUMN2 + " : " + COLUMN3);

            using (var table = db.OpenTable(TABLE))
            {
                var pf = new PredicateFactory(table);

                using (var cursor = table.OpenPrimaryCursor())
                    AssertRC(2, cursor, "Simply enum rows");

                using (var cursor = table.OpenCursor(new Eq<string>(table.GetIndex<string>(COLUMN), "msg3")))
                    AssertRC(1, cursor, "Find where column1 = msg3");

                using (var cursor = table.OpenCursor(pf.Eq(COLUMN, "msg3")))
                    AssertRC(1, cursor, "Find where column1 = msg3");

                using (var cursor = table.OpenCursor(pf.Eq(COLUMN2, message2)))
                    AssertRC(2, cursor, "Find where column2 = message2");

                using (var cursor = table.OpenCursor(new StartsWith(table.GetIndex<string>(COLUMN), "Hell")))
                    AssertRC(1, cursor, "Find where column1 LIKE Hell");

                var predicate = new And(
                    pf.StartsWith(COLUMN, "ms"),
                    pf.Eq(COLUMN2, message2)
                    );

                using (var cursor = table.OpenCursor(predicate))
                    AssertRC(1, cursor, "Find where column1 = ms AND column2 = message2");

                using (var cursor = table.OpenCursor(pf.Between(COLUMN, "zzzs", "msg/", false, true)))
                    AssertRC(1, cursor, "Find column1 between msg/ AND zzzs");

                using (var cursor = table.OpenCursor(new Eq<int>(table.GetIndex<int>(COLUMN4), 4)))
                    AssertRC(1, cursor, "Find column4 = 4");

                using (var cursor = table.OpenCursor(new Eq<int>(table.GetIndex<int>(COLUMN4), 6)))
                    AssertRC(0, cursor, "Find column4 = 6");

                using (var cursor = table.OpenCursor(pf.Le(COLUMN4, 3)))
                    AssertRC(1, cursor, "Find column4 < 3");

                using (var cursor = table.OpenCursor(pf.Le(COLUMN4, 3)))
                {
                    cursor.MoveNext();

                    using (var upd = cursor.EditRow())
                    {
                        upd.SetValue(table.GetColumn<int>(COLUMN4), 6);
                        upd.Save();
                    }

                }
                using (var c2 = table.OpenCursor(pf.Le(COLUMN4, 3)))
                    AssertRC(0, c2, "Find column4 < 3");

                using (var cursor = table.OpenCursor(pf.Eq(COLUMN5, msg)))
                    AssertRC(2, cursor, "Find column5 = longMsg");

                using (var cursor = table.OpenCursor(pf.Eq(COLUMN5, "ON222DT200102011T174244P0Z222")))
                    AssertRC(0, cursor, "Find column5 = longMsg");

                using (var cursor = table.OpenCursor(pf.Eq(COLUMN5, "O")))
                    AssertRC(0, cursor, "Find column5 = longMsg2");

                using (var cursor = table.OpenCursor(pf.Eq(COLUMN5, "4ON2")))
                    AssertRC(0, cursor, "Find column5 = longMsg3");
            }

            Console.WriteLine("---");
            Console.WriteLine("Succeeded {0} out of {1}", Succeeded, Total);
        }