Hiding results with rules

Using an API client

This example uses the saveRule method to hide a record if the query contains the word “cheap”.

Copy

1
2
3
4
5
6
7
8
9
10
11
12
13
14
$rule = [
  'objectID' => 'hide-12345',
  'conditions' => array(array(
    'pattern' => 'cheap',
    'anchoring' => 'contains'
  )),
  'consequence' => [
    'hide' => [
        'objectID' => 'to-hide-12345'
    ]
  ]
];

$index->saveRule($rule);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
rule = {
  objectID: 'hide-12345',
  conditions: [{
    pattern: 'cheap',
    anchoring: 'contains'
  }],
  consequence: {
    hide: {
      objectID: 'to-hide-12345'
    }
  }
}

index.save_rule(rule)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
const rule = {
  objectID: 'hide-12345',
  conditions: [{
    pattern: 'cheap',
    anchoring: 'contains'
  }],
  consequence: {
    hide: {
      objectID: 'to-hide-12345'
    }
  }
};

index.saveRule(rule).then(() => {
  // done
});

1
2
3
4
5
6
7
8
9
10
11
12
13
14
rule = {
    'objectID': 'hide-12345',
    'conditions': [{
        'pattern': 'cheap',
        'anchoring': 'contains'
    }],
    'consequence': {
        'hide': {
            'objectID': 'to-hide-12345'
        }
    }
}

response = index.save_rule(rule)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
let rule = Rule(objectID: "hide-12345")
  .set(\.conditions, to: [
    Rule.Condition()
      .set(\.anchoring, to: .contains)
      .set(\.pattern, to: .literal("cheap"))
  ])
  .set(\.consequence, to: Rule.Consequence()
    .set(\.hide, to: ["to-hide-12345"])
  )

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

1
2
3
4
5
6
7
8
9
val rules = rules {
    rule(
        objectID = "hide-12345",
        conditions = listOf(Condition(Contains, Literal("cheap"))),
        consequence = Consequence(hide = objectIDs { +"to-hide-12345" })
    )
}

index.saveRules(rules)

1
2
3
4
5
6
7
8
9
var rule = new Rule
{
    ObjectID = "hide-12345",
    Conditions = new List<Condition> { new Condition { Anchoring = "contains", Pattern = "cheap" } },
    Consequence = new Consequence
    {
        Hide = new List<Hide> { new Hide { ObjectID = "to-hide-12345" } }
    }
};

1
2
3
4
5
6
7
8
9
10
Condition condition = new Condition().setPattern("cheap").setAnchoring("contains");
Consequence consequence = new Consequence().setHide(Collections.singletonList(new Hide("to-hide-12345")));

Rule rule =
        new Rule()
                .setObjectID("hide-12345")
                .setConditions(Collections.singletonList(condition))
                .setConsequence(consequence);

index.saveRule(rule);

1
2
3
4
5
6
7
8
9
10
11
rule := search.Rule{
	ObjectID:  "hide-12345",
	Conditions: []search.RuleCondition{{Anchoring: search.Contains, Pattern: "cheap"}},
	Consequence: search.RuleConsequence{
		Hide: []search.HiddenObject{
			{"to-hide-12345"},
		},
	},
}

res, err := index.SaveRule(rule)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
val rule = Rule(
  objectID = "hide-12345",
  conditions = Some(Seq(Condition(
    anchoring = "contains",
    pattern = "cheap",
  ))),
  consequence = Consequence(
    hide = Some(Seq(ConsequenceHide("to-hide-12345"))),
  )
)

client.execute {
  save rule rule inIndex "indexName"
}

Using the Visual Editor

Go to the Algolia dashboard and select your Algolia application.
On the left sidebar, select Search.
Select your Algolia index:
Select the Rules section from the left sidebar menu in the Algolia dashboard.
Under the heading Rules, specify the index where you want to add the rule.
Select Create your first rule or New rule. In the drop-down menu, click the Visual Editor option.
In the It all starts here section:
- Click Set query condition(s).
- In the side panel, type your query in the input field, for example, cheap, and click Apply.
In the What do you want to do? section:
- Click Hide items.
- Click Hide by attribute
- In the first box, enter the name of an attribute, such as product_range
- In the second box, enter a value you want to hide, such as premium
- Click Apply.
Click Review and Publish.

Using the Manual Editor

Go to the Algolia dashboard and select your Algolia application.
On the left sidebar, select Search.
Select your Algolia index:
Select the Rules section from the left sidebar menu in the Algolia dashboard.
Under the heading Rules, specify the index where you want to add the rule.
Select Create your first rule or New rule. In the drop-down menu, click the Manual Editor option.
In the Condition(s) section, keep Query toggled on, select Contains in the drop-down menu, and type your query in the input field (for example, cheap).
In the Consequence(s) section:
- Click Add consequence and select Hide an item.
- Click the item you want to hide.
Click Save.

Hiding results with rules

On this page

Using an API client

Using the Visual Editor

Using the Manual Editor

See also

On this page