private static string FormatOperString(FieldQuery query)
 {
     string operStr = string.Empty;
     switch (query.Type) {
         case QueryType.Equal:
             operStr = query.Value == null ? "IS" : "=";
             break;
         case QueryType.NotEqual:
             operStr = query.Value == null ? "NOT IS" : "<>";
             break;
         case QueryType.Greater: operStr = ">";
             break;
         case QueryType.GreaterOrEqual: operStr = ">=";
             break;
         case QueryType.Less: operStr = "<";
             break;
         case QueryType.LessOrEqual: operStr = "<=";
             break;
         case QueryType.In: operStr = "IN";
             break;
         case QueryType.NotIn: operStr = "NOT IN";
             break;
         case QueryType.Like: operStr = "LIKE";
             break;
     }
     return operStr;
 }
 protected virtual Query ConvertFieldQuery(FieldQuery query)
 {
    try
    {
       return InternalParse(query.FieldValue, Escape(query.FieldName));
    }
    catch
    {
       return InternalParse(Escape(query.FieldValue), Escape(query.FieldName));
    }
 }
 public static IQueryExpression FilterByIdsToInclude(this IQueryExpression expression, IList <int> IdsToInclude)
 {
     if (IdsToInclude != null && IdsToInclude.Any())
     {
         foreach (var id in IdsToInclude)
         {
             var fieldQuery = new FieldQuery(Constants.INDEX_FIELD_NAME_ID, ContentIndexHelpers.GetIndexFieldId(new ContentReference(id)), true);
             expression = expression.Or(fieldQuery);
         }
     }
     return(expression);
 }
Example #4
0
        private void SetupHighlighter(IndexQueryServerSide query, Query luceneQuery, JsonOperationContext context)
        {
            var fragmentsBuilder = new PerFieldFragmentsBuilder(query, context);

            _highlighter = new FastVectorHighlighter(
                FastVectorHighlighter.DEFAULT_PHRASE_HIGHLIGHT,
                FastVectorHighlighter.DEFAULT_FIELD_MATCH,
                new SimpleFragListBuilder(),
                fragmentsBuilder);

            _highlighterQuery = _highlighter.GetFieldQuery(luceneQuery);
        }
Example #5
0
        protected void ApplyTemplateFilter(CombinedQuery query, string templateIds)
        {
            if (String.IsNullOrEmpty(templateIds))
            {
                return;
            }

            templateIds = IdHelper.NormalizeGuid(templateIds);
            var fieldQuery = new FieldQuery(BuiltinFields.Template, templateIds);

            query.Add(fieldQuery, QueryOccurance.Must);
        }
Example #6
0
 protected virtual Query ConvertFieldQuery(FieldQuery query)
 {
     try
     {
         return(this.InternalParse(query.FieldValue, Escape(query.FieldName)));
     }
     catch (Exception exc)
     {
         Log.Info("Tried to convert unescaped field but failed. If this continues, considering change the name of the FieldName for ", exc);
         return(this.InternalParse(Escape(query.FieldValue), Escape(query.FieldName)));
     }
 }
        private QueryBase CreateQuery(Database database)
        {
            var query = new CombinedQuery();
            var databaseQuery = new FieldQuery(BuiltinFields.Database, database.Name);
            var languageQuery = new FieldQuery(BuiltinFields.Language, Context.Language.Name);
            var templateQuery = new FieldQuery(BuiltinFields.Template, ShortID.Encode(RewriteReportItem.TemplateId));

            query.Add(databaseQuery, QueryOccurance.Must);
            query.Add(languageQuery, QueryOccurance.Must);
            query.Add(templateQuery, QueryOccurance.Must);

            return query;
        }
Example #8
0
        public ActionResult Index(SearchPage currentPage, string q)
        {
            var viewmodel = new SearchPageViewModel(currentPage);

            viewmodel.StartPage = loader.Get <StartPage>(ContentReference.StartPage);

            viewmodel.MenuPages = FilterForVisitor.Filter(
                loader.GetChildren <SitePageData>(ContentReference.StartPage))
                                  .Cast <SitePageData>().Where(page => page.VisibleInMenu);

            viewmodel.Section = currentPage.ContentLink.GetSection();

            if (!string.IsNullOrWhiteSpace(q))
            {
                // 1. only pages
                var onlyPages = new ContentQuery <SitePageData>();

                // 2. free-text query
                var freeText = new FieldQuery(q);

                // 3. only what the current user can read
                var readAccess = new AccessControlListQuery();
                readAccess.AddAclForUser(PrincipalInfo.Current, HttpContext);

                // 4. only under the Start page (to exclude Wastebasket, for example)
                var underStart = new VirtualPathQuery();
                underStart.AddContentNodes(ContentReference.StartPage);

                // build the query from the expressions
                var query = new GroupQuery(LuceneOperator.AND);
                query.QueryExpressions.Add(freeText);
                query.QueryExpressions.Add(onlyPages);
                query.QueryExpressions.Add(readAccess);
                query.QueryExpressions.Add(underStart);

                // get the first page of ten results
                SearchResults results = searchHandler.GetSearchResults(query, 1, 10);

                viewmodel.SearchText = q;

                viewmodel.SearchResults = results.IndexResponseItems
                                          .Select(item => new Result
                {
                    Title       = item.Title,
                    Description = item.DisplayText?.TruncateAtWord(20),
                    Url         = ConvertToUri(item).ToString()
                }).ToList();
            }
            return(View(viewmodel));
        }
Example #9
0
        protected static bool TryBlock(Map map, Vector3 origin, DamageDef damType, int damAmount, Vector3 position)
        {
            if (damType?.defName == null)
            {
                return(false);
            }
            var damages = new ShieldDamages(new ShieldDamage(damType, damAmount));
            var blocked = new FieldQuery(map)
                          .IsActive()
                          .Intersects(origin, PositionUtility.ToVector3(position).Yto0())
                          .Block(damages);

            return(blocked);
        }
Example #10
0
        public void Search(string q)
        {
            var culture = ContentLanguage.PreferredCulture.Name;

            SearchResult = new List <IndexResponseItem>();

            var fieldQuery = new FieldQuery(q);

            var fieldQueryResult = SearchHandler.Instance.GetSearchResults(fieldQuery, 1, 40)
                                   .IndexResponseItems
                                   .Where(x =>
                                          (x.Culture.Equals(culture) || string.IsNullOrEmpty(x.Culture)))
                                   .ToList();

            SearchResult.AddRange(fieldQueryResult);
        }
Example #11
0
            static bool AddShieldCheck(bool result, TargetInfo target)
            {
                if (result)
                {
                    var blocked = new FieldQuery(target.Map)
                                  .Intersects(target.Cell.ToVector3().Yto0())
                                  .Get()
                                  .Any();
                    if (blocked)
                    {
                        return(false);
                    }
                }

                return(result);
            }
Example #12
0
        private void MakeSearch(string q, ProductListPageViewModel viewmodel)
        {
            // 1. only productpages
            var onlyPages = new ContentQuery <ProductPage>();

            // 2. free-text query
            var freeText = new FieldQuery(q);

            // 3. only what the current user can read
            var readAccess = new AccessControlListQuery();

            readAccess.AddAclForUser(PrincipalInfo.Current, HttpContext);

            // 4. only productpages
            var inProductPages = new VirtualPathQuery();

            foreach (var page in viewmodel.MenuPages.Where(p => p.Name == "Shop"))
            {
                inProductPages.AddContentNodes(page.Page.ContentLink);
            }

            // build the query from the expressions
            var query = new GroupQuery(LuceneOperator.AND);

            query.QueryExpressions.Add(freeText);
            query.QueryExpressions.Add(onlyPages);
            query.QueryExpressions.Add(readAccess);
            query.QueryExpressions.Add(inProductPages);

            // get the first page of ten results
            SearchResults results = searchHandler.GetSearchResults(query, 1, 10);

            viewmodel.SearchText = q;

            if (results.TotalHits > 0)
            {
                viewmodel.ProductsToDisplay =
                    results.IndexResponseItems
                    .Where(p => p.Id.ToUpper().Contains(Thread.CurrentThread.CurrentUICulture.Name.ToUpper()))
                    .Select(p => loader.Get <ProductPage>(Guid.Parse(p.Id.Split('|').First())))
                    .ToList();
            }
            else
            {
                viewmodel.ProductsToDisplay = new List <ProductPage>();
            }
        }
 private static string FormatLeftOperValue(FieldQuery query, DatabaseType dbType)
 {
     string leftOperValue = query.Key;
     if (dbType == DatabaseType.SQLServer) {
         if (query.Value is DateTime) {
             leftOperValue = string.Format("CONVERT(VARCHAR(8),[{0}],12)", query.Key);
         }
         else if (query.Value is Array) {
             foreach (var v in query.Value as Array) {
                 if (!(v is DateTime))
                     return leftOperValue;
             }
             leftOperValue = string.Format("CONVERT(VARCHAR(8),[{0}],12)", query.Key);
         }
     }
     return leftOperValue;
 }
Example #14
0
        public void Get_All_Not_Const_Fields()
        {
            var query   = new FieldQuery("!const * *");
            var matches = query.GetMatchingFields(myFieldClass);

            try
            {
                Assert.AreEqual(10, matches.Count, "Field Count");
            }
            finally
            {
                foreach (var field in matches)
                {
                    Console.WriteLine("Field: {0}", field.Print(FieldPrintOptions.All));
                }
            }
        }
Example #15
0
        public void Get_All_NotReadOnly_NotProtected_Fields()
        {
            var query   = new FieldQuery("!readonly !protected * *");
            var matches = query.GetMatchingFields(myFieldClass);

            try
            {
                Assert.AreEqual(9, matches.Count, "Field Count");
            }
            finally
            {
                foreach (var field in matches)
                {
                    Console.WriteLine("Field: {0}", field.Print(FieldPrintOptions.All));
                }
            }
        }
Example #16
0
        private static bool Block(Bullet crashPod, int damage)
        {
            var crashPodBlocked = new FieldQuery(crashPod.Map)
                                  .IsActive()
                                  .Intersects(PositionUtility.ToVector3WithY(crashPod.Position, 0))
                                  .Block(damage);

            if (crashPodBlocked)
            {
                Messages.Message("fd.shields.incident.crashpod.blocked.body".Translate(),
                                 new GlobalTargetInfo(crashPod.Position, crashPod.Map), MessageTypeDefOf.NeutralEvent);
                crashPod.def.projectile.soundExplode.PlayOneShot(
                    SoundInfo.InMap(new TargetInfo(crashPod.Position, crashPod.Map)));
                crashPod.Destroy();
                return(true);
            }

            return(false);
        }
            static float AdjustScoreForShieldedTargets(float __result, IAttackTarget target, IAttackTargetSearcher searcher, Verb verb)
            {
                if (!Mod.Settings.EnableAIAttackTargetFinder)
                {
                    return(__result);
                }
                var targetShielded = new FieldQuery(searcher.Thing.Map)
                                     .IsActive()
                                     .Intersects(
                    PositionUtility.ToVector3(searcher.Thing.Position),
                    PositionUtility.ToVector3(target.Thing.Position))
                                     .Get()
                                     .Any();

                if (targetShielded)
                {
                    return(__result / 2);
                }
                return(__result);
            }
        public List <FieldReportObject> GetOrderedFieldReportObjects(FieldQuery queryBuilder)
        {
            try
            {
                using (var db = new DPRDataMigrationEngineDBEntities())
                {
                    if (queryBuilder != null)
                    {
                        var query = (

                            from f in db.Fields.OrderBy(m => m.Name)
                            join c in db.Companies on f.CompanyId equals c.CompanyId
                            where ((queryBuilder.CompanyId > 0 && queryBuilder.CompanyId == c.CompanyId) || (queryBuilder.CompanyId < 1 && f.CompanyId == c.CompanyId))
                            join t in db.Terrains on f.TerrainId equals t.TerrainId
                            where ((queryBuilder.TerrainId > 0 && queryBuilder.TerrainId == t.TerrainId) || (queryBuilder.TerrainId < 1 && f.TerrainId == t.TerrainId))
                            join b in db.Blocks on f.BlockId equals b.BlockId
                            where ((queryBuilder.BlockId > 0 && queryBuilder.BlockId == b.BlockId) || (queryBuilder.BlockId < 1 && f.BlockId == b.BlockId))
                            join z in db.Zones on f.ZoneId equals z.ZoneId
                            where ((queryBuilder.ZoneId > 0 && z.ZoneId == queryBuilder.ZoneId) || (z.ZoneId == f.ZoneId && queryBuilder.ZoneId < 1))

                            select new FieldReportObject
                        {
                            Name = t.Name,
                            FieldName = f.Name,
                            BlockName = b.Name,
                            CompanyName = c.Name,
                            ZoneName = z.Name,
                            TerrainName = t.Name,
                        }).ToList();

                        return(!query.Any() ? new List <FieldReportObject>() : query);
                    }
                    return(new List <FieldReportObject>());
                }
            }
            catch (Exception ex)
            {
                ErrorLogger.LogEror(ex.StackTrace, ex.Source, ex.Message);
                return(new List <FieldReportObject>());
            }
        }
Example #19
0
        /// <summary>
        /// Runs Lucene Highlighter module over search results and original Lucene Query.
        /// </summary>
        /// <param name="query"></param>
        /// <returns>List of results transformed into LuceneSearchResult DTOs.</returns>
        protected IList <LuceneSearchResult> TransformTopDocs(Query query)
        {
            if (this.topDocs != null)
            {
                IList <LuceneSearchResult> results = new List <LuceneSearchResult>();

                FastVectorHighlighter highlighter = new FastVectorHighlighter(true, true,
                                                                              new SimpleFragListBuilder(), new ScoreOrderFragmentsBuilder(
                                                                                  BaseFragmentsBuilder.COLORED_PRE_TAGS,
                                                                                  BaseFragmentsBuilder.COLORED_POST_TAGS));
                FieldQuery fieldQuery = highlighter.GetFieldQuery(query);

                foreach (ScoreDoc scoreDoc in this.topDocs.ScoreDocs)
                {
                    string snippet = highlighter.GetBestFragment(fieldQuery, this.searcher.IndexReader, scoreDoc.Doc, "FileData", 200);
                    results.Add(new LuceneSearchResult(this.searcher.Doc(scoreDoc.Doc), scoreDoc.Score, this.topDocs.TotalHits, snippet));
                }

                return(results);
            }
            return(null);
        }
Example #20
0
        static void CAMLQueryWithSubQueryAndOrderby()
        {
            List<string> status = new List<string>();
            status.Add("Status1");
            status.Add("Status2");

            List<SubQuery> queries = new List<SubQuery>();
            foreach (string sta in status)
            {
                List<FieldQuery> singleQueries = new List<FieldQuery>();

                QBField Statusfield = new QBField("LU_Status", sta, FieldType.Lookup);
                QBField StatusHiddenfield = new QBField("StatusHidden", sta, FieldType.Text);

                FieldQuery sqe1 = new FieldQuery(StatusHiddenfield, OperationType.Neq, OperatorType.And);
                FieldQuery sqe = new FieldQuery(Statusfield, OperationType.Eq, OperatorType.And);

                singleQueries.Add(sqe1);
                singleQueries.Add(sqe);

                SubQuery subQuery = new SubQuery(singleQueries, OperatorType.Or);
                queries.Add(subQuery);
            }

            QBField domainName = new QBField();
            domainName.Name = "DomainName";
            QBField statusF = new QBField();
            statusF.Name = "LU_Status";

            List<QBOrderBy> allOrderBy = new List<QBOrderBy>();
            allOrderBy.Add(domainName.OrderByExpressionAsc);
            allOrderBy.Add(statusF.OrderByExpressionDesc);

            OrderByQuery orderByQuery = new OrderByQuery(allOrderBy);

            CAMLQuery oCAMLquery = new CAMLQuery(queries, 47, orderByQuery);

            Console.Write(oCAMLquery.ViewExpression);
        }
Example #21
0
        private static void AddFieldToQuery(GroupQuery groupQuery, string keyword, Field field, bool wildcard = true)
        {
            if (wildcard)
            {
                if (keyword.StartsWith("\"") && keyword.EndsWith("\""))
                {
                    var fieldQuery = new FieldQuery(keyword.Trim(), field);
                    groupQuery.QueryExpressions.Add(fieldQuery);
                    return;
                }

                if (keyword.Trim().Contains(" "))
                {
                    var words = keyword.Trim().Split(new[] { " " }, StringSplitOptions.RemoveEmptyEntries);
                    var query = new GroupQuery(LuceneOperator.OR);
                    foreach (string w in words)
                    {
                        if (w.Equals("and") || w.Equals("+"))
                        {
                            continue;
                        }
                        var s = w.Replace("\"", string.Empty).Trim();
                        var f = new FieldQuery(string.Format("{0}*", LuceneHelpers.Escape(s)), field);
                        query.QueryExpressions.Add(f);
                    }
                    groupQuery.QueryExpressions.Add(query);
                }
                else
                {
                    var fieldQuery = new FieldQuery(string.Format("{0}*", LuceneHelpers.Escape(keyword)), field);
                    groupQuery.QueryExpressions.Add(fieldQuery);
                }
            }
            else
            {
                var fieldQuery = new FieldQuery(string.Format("{0}", LuceneHelpers.Escape(keyword.Trim())), field);
                groupQuery.QueryExpressions.Add(fieldQuery);
            }
        }
Example #22
0
        public long AddFieldQueryCheckDuplicate(FieldQuery fieldQuery)
        {
            try
            {
                if (fieldQuery == null)
                {
                    return(-2);
                }
                using (var db = new QueryBuilderEntities())
                {
                    if (db.FieldQueries.Any())
                    {
                        if (db.FieldQueries.Count(m => m.ZoneId == fieldQuery.ZoneId &&
                                                  m.CompanyId == fieldQuery.CompanyId &&
                                                  m.TerrainId == fieldQuery.TerrainId &&
                                                  m.ZoneId == fieldQuery.ZoneId
                                                  ) > 0)
                        {
                            return(-3);
                        }

                        if (db.FieldQueries.Count(m => m.FieldQueryName.ToLower().Trim().Replace(" ", "") == fieldQuery.FieldQueryName.ToLower().Trim().Replace(" ", "")
                                                  ) > 0)
                        {
                            return(-4);
                        }
                    }

                    var processedFieldQuery = db.FieldQueries.Add(fieldQuery);
                    db.SaveChanges();
                    return(processedFieldQuery.FieldQueryId);
                }
            }
            catch (Exception ex)
            {
                ErrorLogger.LogEror(ex.StackTrace, ex.Source, ex.Message);
                return(0);
            }
        }
 static bool CanShootAtShieldFromCurrentPosition(bool __result, IAttackTarget target, IAttackTargetSearcher searcher, Verb verb)
 {
     if (!Mod.Settings.EnableAIAttackTargetFinder)
     {
         return(__result);
     }
     if (__result == false)
     {
         try
         {
             var result = new FieldQuery(searcher.Thing.Map)
                          .IsActive()
                          .HostileTo(searcher.Thing.Faction)
                          .Intersects(
                 PositionUtility.ToVector3(searcher.Thing.Position),
                 PositionUtility.ToVector3(target.Thing.Position))
                          .GetWithIntersects()
                          .First();
             if (result.Second == null)
             {
                 return(false);
             }
             var distance = Vector3.Distance(searcher.Thing.TrueCenter(), result.Second.Value);
             var range    = verb.verbProps.range;
             var isTarget = result.First.Emitters
                            .Select(emitter => emitter.Thing)
                            .Any(thing => thing == target.Thing);
             if (distance <= range && isTarget)
             {
                 return(true);
             }
         }
         catch (InvalidOperationException)
         {
         }
     }
     return(__result);
 }
Example #24
0
        public override bool ExtractAndValidateTypeQuery(string query)
        {
            bool lret = base.ExtractAndValidateTypeQuery(query);

            if (lret == false)
            {
                Out.WriteLine("The Type/field query must be of the form typeName([<visiblity>] <type name> <field name>)");
                Out.WriteLine("Example: *(public * *) searches for all public fields in the whole assembly defined in the assembly given in the -in query");
            }
            else
            {
                if (base.myInnerQuery.Trim() == "*")
                {
                    myFieldQuery = FieldQuery.AllFields;
                }
                else
                {
                    myFieldQuery = new FieldQuery("nocompilergenerated " + base.myInnerQuery);
                }
            }

            return(lret);
        }
Example #25
0
        public ActionResult GetFields(FieldQuery queryBuilder)
        {
            if (queryBuilder == null)
            {
                return(Json(new List <FieldReportObject>(), JsonRequestBehavior.AllowGet));
            }

            if (queryBuilder.TerrainId < 1 && queryBuilder.CompanyId < 1 && queryBuilder.ZoneId < 1)
            {
                return(Json(new List <FieldReportObject>(), JsonRequestBehavior.AllowGet));
            }

            var fieldList = new FieldServices().GetOrderedFieldReportObjects(queryBuilder) ?? new List <FieldReportObject>();

            if (!fieldList.Any())
            {
                return(Json(new List <FieldReportObject>(), JsonRequestBehavior.AllowGet));
            }
            Session["_successfulFieldQuery"] = queryBuilder;
            var jsonResult = Json(fieldList, JsonRequestBehavior.AllowGet);

            jsonResult.MaxJsonLength = int.MaxValue;
            return(jsonResult);
        }
Example #26
0
        private QueryBase GetQuery(QueryInfo qi)
        {
            if (String.IsNullOrEmpty(qi.SearchString) ||
                String.IsNullOrEmpty(qi.FieldName) ||
                Index == null)
            {
                return(null);
            }

            QueryBase query = null;

            switch (qi.QueryType)
            {
            case "FieldQuery":
                query = new FieldQuery(qi.FieldName, qi.SearchString);
                break;

            default:
                query = new FullTextQuery(qi.SearchString);
                break;
            }

            return(query);
        }
        private QueryBase GetQuery(QueryInfo qi)
        {
            if (String.IsNullOrEmpty(qi.SearchString) ||
                String.IsNullOrEmpty(qi.FieldName) ||
                Index == null)
            {
                return null;
            }

            QueryBase query = null;

            switch (qi.QueryType)
            {
                case "FieldQuery":
                    query = new FieldQuery(qi.FieldName, qi.SearchString);
                    break;

                default:
                    query = new FullTextQuery(qi.SearchString);
                    break;
            }

            return query;
        }
 protected virtual Query ConvertFieldQuery(FieldQuery query)
 {
     try
     {
         return this.InternalParse(query.FieldValue, Escape(query.FieldName));
     }
     catch (Exception exc)
     {
         Log.Info("Tried to convert unescaped field but failed. If this continues, considering change the name of the FieldName for ", exc);
         return this.InternalParse(Escape(query.FieldValue), Escape(query.FieldName));
     }
 }
Example #29
0
 internal virtual KeyValuePair<int, List<SitecoreItem>> GetItemsViaFieldQuery(string fieldName, string fieldValue, int numberOfResults)
 {
     var query = new FieldQuery(fieldName, fieldValue);
     return this.RunQuery(query, numberOfResults);
 }
Example #30
0
        protected void ApplyTemplateFilter(CombinedQuery query, string templateIds, QueryOccurance occurance)
        {
            if (String.IsNullOrEmpty(templateIds)) return;

            templateIds = IdHelper.NormalizeGuid(templateIds);
            var fieldQuery = new FieldQuery(BuiltinFields.Template, templateIds);
            query.Add(fieldQuery, occurance);
        }
Example #31
0
 public static UQuery Eq(string key, object value)
 {
     FieldQuery query = new FieldQuery(key, value, QueryType.Equal);
     return query;
 }
        internal static void ApplyLatestVersion(CombinedQuery globalQuery)
        {
            var fieldQuery = new FieldQuery(BuiltinFields.LatestVersion, "1");

            globalQuery.Add(fieldQuery, QueryOccurance.Must);
        }
        internal virtual KeyValuePair <int, List <SitecoreItem> > GetItemsViaFieldQuery(string fieldName, string fieldValue, int numberOfResults)
        {
            var query = new FieldQuery(fieldName, fieldValue);

            return(this.RunQuery(query, numberOfResults));
        }
Example #34
0
 public static UQuery In(string key, Array values)
 {
     FieldQuery query = new FieldQuery(key, values, QueryType.In);
     return query;
 }
Example #35
0
 public static UQuery Gt(string key, object value)
 {
     FieldQuery query = new FieldQuery(key, value, QueryType.Greater);
     return query;
 }
 internal static void ApplyLatestVersion(CombinedQuery globalQuery)
 {
     var fieldQuery = new FieldQuery(BuiltinFields.LatestVersion, "1");
     globalQuery.Add(fieldQuery, QueryOccurance.Must);
 }
Example #37
0
 public static UQuery Lk(string key, string value)
 {
     FieldQuery query = new FieldQuery(key, value, QueryType.Like);
     return query;
 }
Example #38
0
 public static UQuery Lk(string key, Regex regex)
 {
     FieldQuery query = new FieldQuery(key, regex.ToString(), QueryType.Like);
     return query;
 }
Example #39
0
 public static UQuery Lt(string key, object value)
 {
     FieldQuery query = new FieldQuery(key, value, QueryType.Less);
     return query;
 }
        public static IQueryExpression FilterByPublished(this IQueryExpression expression)
        {
            var fieldQuery = new FieldQuery(Constants.INDEX_FIELD_NAME_STATUS, ((int)VersionStatus.Published).ToString());

            return(expression.And(fieldQuery));
        }
        public static IQueryExpression FilterByLanguage(this IQueryExpression expression, string language)
        {
            var fieldQuery = new FieldQuery(Constants.INDEX_FIELD_NAME_LANGUAGE, language.ToString());

            return(expression.And(fieldQuery));
        }
Example #42
0
 protected InsertProxyBase()
 {
     FieldQuery = new FieldQuery();
 }