Batch Rules | Ruby API Client V1 (Deprecated)

1
2
3
4
5
6
7
8
9
10
11
12
rules = [rule1, rule2]
forward_to_replicas = true
clear_existing_rules = true

# Save the rules.
index.batch_rules(rules)
# Save the rules and wait the end of indexing.
index.batch_rules!(rules)
# Save the rules, and forward them to all replicas of the index.
index.batch_rules(rules, forward_to_replicas)
# Replace all the rules in the index by the provided ones.
index.batch_rules(rules, forward_to_replicas, clear_existing_rules)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
const rules = [
  {
    objectID: 'rule-1',
    condition: {
      pattern: 'smartphone',
      anchoring: 'contains'
    },
    consequence: {
      params: {
        filters: 'category = 1'
      }
    }
  },
  {
    objectID: 'rule-2',
    condition: {
      pattern: 'tv',
      anchoring: 'contains'
    },
    consequence: {
      params: {
        filters: 'category = 2'
      }
    }
  }
];

// Save the rules.
index.saveRules(rules).then(() => {
  // done
});

// Replace all the rules in the index by the provided ones.
index.saveRules(rules, { clearExistingRules: true }).then(() => {
  // done
});

// Save the rules, and forward them to all replicas of the index.
index.saveRules(rules, { forwardToReplicas: true }).then(() => {
  // done
});

1
2
3
rules = [rule1, rule2]

index.save_rules(rules)

1
2
3
4
5
6
7
8
9
let rules: [Rule] = [/* Your Query rules */]

index.saveRules(rules,
                forwardToReplicas: true,
                clearExistingRules: true) { result in
  if case .success(let response) = result {
    print("Response: \(response)")
  }
}

1
2
3
4
5
List<Rule> rules;
index.SaveRules(rules, forwardToReplicas: true, clearExistingRules: false);

// Asynchronous
await index.SaveRulesAsync(rules, forwardToReplicas: true, clearExistingRules: false);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
boolean forwardToReplicas = false;
boolean clearExistingRules = false;

index.saveRules(
  Arrays.asList(rule1, rule2),
  forwardToReplicas,
  clearExistingRules
);

index.saveRulesAsync(
  Arrays.asList(rule1, rule2),
  forwardToReplicas,
  clearExistingRules
);

1
2
3
4
5
6
7
8
rules := []search.Rule{rule1, rule2}

opts := []interface{}{
  opt.ForwardToReplicas(false),
  opt.ClearExistingRules(false),
}

res, err := index.SaveRules(rules, opts...)

1
2
3
client.execute {
  save rules Seq(rule1, rule2) inIndex "index_name"
}

1
2
3
val rules = listOf<Rule>()

index.saveRules(rules, forwardToReplicas = true, clearExistingRules = true)