Search Rules

Required API Key: any key with the settings ACL

Method signature

$index->searchRules(string query)

$index->searchRules(string query, [
  // All the following parameters are optional
  'anchoring' => string,
  'context' => string,
  'page' => integer,
  'hitsPerPage' => integer,
  'enabled' => boolean
])

index.search_rules(
  String query,
  Hash opts = {
    anchoring: String,
    context: String,
    page: Integer,
    hitsPerPage: Integer,
    enabled: Boolean
  }
)

index.searchRules(string query)

index.searchRules(string query, {
  // All the following parameters are optional
  anchoring => string,
  context => string,
  page => integer,
  hitsPerPage => integer,
  enabled => boolean,
  // any other requestOptions
})

index.search_rules(str query, {
    // All the following parameters are optional
    'anchoring': str,
    'context': str,
    'page': int,
    'hitsPerPage': int,
    'enabled': bool
})

index.searchRules(
  _ query: RuleQuery,
  requestOptions: RequestOptions? = nil,
  completion: Result<RuleSearchResponse> -> Void
)

struct RuleQuery {
  var query: String? = nil
  var anchoring: Rule.Anchoring? = nil
  var context: String? = nil
  var page: Int? = nil
  var hitsPerPage: Int? = nil
  var isEnabled: Bool? = nil
}

suspend fun Index.searchRules(
  query: RuleQuery = RuleQuery(),
  requestOptions: RequestOptions? = null
): ResponseSearchRules

@Serializable
data class RuleQuery(
    var query: String? = null,
    var anchoring: Anchoring? = null,
    var context: String? = null,
    var page: Int? = null,
    var hitsPerPage: Int? = null,
    var enabled: Boolean? = null
)

index.SearchRules(
  new RuleQuery
  {
    Query = String,
    Anchoring = String,
    Context = String,
    Page = int,
    HitsPerPage = int,
    Enabled = bool,
  })

index.searchRules(
  new RuleQuery(String query)
    .setAnchoring(String anchoring)
    .setContext(String context)
    .setPage(int page)
    .setHitsPerPage(int hitsPerPage)
    .setEnabled(bool enabled)
)

index.SearchRules(string query)
index.SearchRules(
  string query,
  opt.Anchoring(string anchoring),
  opt.RuleContexts(string context),
  opt.Page(int page),
  opt.HitsPerPage(int hitsPerPage),
  opt.EnableRules(bool enabled),
)

search.rules(in).index("indexName").query(
  QueryRules(
    query = String,
    anchoring = String,
    context = String,
    page = int,
    hitsPerPage = int,
    enabled = bool,
  )
)

See code examples

About this method # A

Search for rules matching various criteria.

Examples # A

Copy

1
2
3
$response = $index->searchRules('something', [
  'enabled' => true
]);

1
2
3
4
5
6
7
8
9
10
11
let query = RuleQuery()
  .set(\.anchoring, to: .is)
  .set(\.page, to: 1)
  .set(\.hitsPerPage, to: 10)
  .set(\.context, to: "something")

index.searchRules(query) { result in
  if case .success(let response) = result {
    print("Response: \(response)")
  }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
index.SearchRules( new RuleQuery("query")
  {
    Anchoring = "is",
    Context = "something",
    Page = 1,
    HitsPerPage = 10
  }
);

// Asynchronous
await index.SearchRulesAsync( new RuleQuery("query")
  {
    Anchoring = "is",
    Context = "something",
    Page = 1,
    HitsPerPage = 10
  }
);

1
2
3
4
5
6
7
8
9
// Sync
SearchResult<Rule> results = index.searchRules(
  new RuleQuery("something")
);

// Async
CompletableFuture<SearchResult<Rule>> results = index.searchRulesAsync(
  new RuleQuery("something")
);

1
2
3
4
5
6
7
8
opts := []interface{}{
  opt.Anchoring("is"),
  opt.RuleContexts("something"),
  opt.Page(1),
  opt.HitsPerPage(10),
}

res, err := index.SearchRules("query", opts...)

Parameters # A

`query` #	type: string default: "" Optional Full text query.
`anchoring` #	type: string\|enum default: all anchoring Optional When specified, restricts matches to rules with a specific anchoring type. When omitted, all anchoring types may match. One of the following values: `is`, `startsWith`, `endsWith`, `contains`
`context` #	type: string default: Any context Optional Restricts matches to contextual rules with a specific context (exact match).
`page` #	type: integer default: 0 Optional Requested page (zero-based).
`hitsPerPage` #	type: integer default: 20 Optional Maximum number of hits in a page. Minimum is 1, maximum is 1000.
`enabled` #	type: boolean default: none Optional When specified, restricts matches to rules with a specific `enabled` status. When absent (default), all rules are retrieved, regardless of their `enabled` status.
`requestOptions` #	type: key/value mapping default: No request options Optional A mapping of `requestOptions` to send along with the request.

Response # A

This section shows the JSON response returned by the API. Since each language encapsulates this response inside objects specific to that language and/or implementation, the actual type in your language might differ from what’s written here. You can view the response in the logs (using the getLogs method).

JSON format#

Copy

          {
  "hits":[
    {
      "conditions":[{
        "pattern":"smartphone",
        "anchoring":"contains"
      }],
      "consequence":{
        "params":{
          "filters":"category = 1"
        }
      },
      "objectID":"a-rule-id",
      "_highlightResult":{
        "conditions":[{
          "pattern":{
            "value":"<b>s<\/b>martphone",
            "matchLevel":"full",
            "fullyHighlighted":false,
            "matchedWords":[
              "s"
            ]
          }],
          "anchoring":{
            "value":"contains",
            "matchLevel":"none",
            "matchedWords":[

            ]
          }
        },
        "consequence":{
          "params":{
            "filters":{
              "value":"category = 1",
              "matchLevel":"none",
              "matchedWords":[

              ]
            }
          }
        }
      }
    }
  ],
  "nbHits":1,
  "page":0,
  "nbPages":1
}

        

`hits` #	list of rule Rule objects matched by the search query (see Rule Schema). Highlighting is provided through the standard mechanism (`_highlightResult` attribute inside every returned object)
`nbHits` #	integer Total number of rules matching the query.
`page` #	integer Returned page number (zero-based).
`nbPages` #	integer Total number of pages.

Did you find this page helpful?

Search Rules

About this method # Found an issue? Edit this page A Edit this page

Examples # Found an issue? Edit this page A Edit this page

Parameters # Found an issue? Edit this page A Edit this page

Response # Found an issue? Edit this page A Edit this page

JSON format#

On this page

About this method # A

Examples # A

Parameters # A

Response # A