Adding default search parameters with Rules

Using the API

To create a Rule with an API client, use the saveRule method on a Rule object without a condition.

Copy

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
$rule = array(
    'objectID' => 'a-rule-id',
    'consequence' => array(
        'params' => array(
            'aroundRadius' => 1000,
        )
    )
);

// set validity to 30 days
$rule['validity'] = array(
  array(
    'from' => time(),
    'until' => time() + 30*24*60*60,
  )
);
$index->saveRule($rule);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
rule = {
  objectID: 'a-rule-id',
  consequence: {
    params: {
      aroundRadius: 1000
    }
  }
}

# set validity to 30 days
# (with `require 'date'`)
rule['validity'] = [
  {
    from: Time.now.to_i,
    until: (DateTime.now + 30).to_time.to_i,
  }
]

index.save_rule(rule)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
const rule = {
  objectID: 'a-rule-id',
  consequence: {
    params: {
      aroundRadius: 1000
    }
  }
};

// set valitidy to 30 days
rule['validity'] = [
  {
    'from': Math.floor(Date.now()/1000),
    'until': Math.floor(Date.now()/1000) + 30*24*60*60,
  }
];
index.saveRule(rule).then(() => {
  // done
});

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
rule = {
    'objectID': 'a-rule-id',
    'consequence': {
        'params': {
            'aroundRadius': 1000
        }
    }
}

# set validity to 30 days
# Python 2 (with `time` and `datetime.timedelta` imports)
rule['validity'] = [
    {
        'from': int(time.time()),
        'until': int(time.time() + timedelta(days=30).total_seconds())
    }
]

# Python 3 (with `datetime.{datetime,timedelta}` imports)
rule['validity'] = [
    {
        'from': int((datetime.datetime.utcnow().timestamp())),
        'until': int(
            (datetime.datetime.utcnow() + timedelta(days=30)).timestamp())
    }
]
response = index.save_rule(rule)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
let rule = Rule(objectID: "a-rule-id")
  .set(\.consequence, to: Rule.Consequence()
    .set(\.query, to: Query()
      .set(\.aroundRadius, to: .meters(1000))
    )
  )
  // set validity to 30 days
  .set(\.validity, to: [.init(from: Date(), until: Date().addingTimeInterval(30 * 24 * 60 * 60))])

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

1
2
3
4
5
6
7
8
9
val rule = Rule(
    objectID = ObjectID("a-rule-id"),
    consequence = Consequence(
        query = Query(aroundRadius = 1000)
    ),
    // set validity to 30 days
    validity = listOf(TimeRange(0, 30))
)
index.saveRule(rule)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
Rule ruleToSave = new Rule
{
    ObjectID = "a-rule-id",
    Consequence = new Consequence
    {
        Params = new ConsequenceParams
        {
            AroundRadius = 1000
        }
    },
    {
        new TimeRange // set validity to 30 days
        {
            From = new DateTimeOffset(DateTime.UtcNow).ToUnixTimeSeconds(),
            Until = new DateTimeOffset(DateTime.UtcNow.AddDays(30)).ToUnixTimeSeconds()
        }
    }
  };
index.SaveRule(rule);
// Asynchronous
await index.SaveRuleAsync(rule);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
Consequence consequence =
    new Consequence()
        .setParams(
            new ConsequenceParams()
                .setAroundRadius(1000));

// set validity to 30 days
List<TimeRange> validity =
        Collections.singletonList(
                new TimeRange(
                        OffsetDateTime.now(ZoneOffset.UTC),
                        OffsetDateTime.now(ZoneOffset.UTC).plusDays(30));

Rule rule = new Rule()
        .setObjectID("a-unique-identifier")
        .setConsequence(consequence);
        .setValidity(validity);

index.saveRule(rule);
// Asynchronous
index.saveRuleAsync(rule);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
rule := search.Rule{
  ObjectID:  "a-rule-id",
  Consequence: search.RuleConsequence{
    Params: &search.RuleParams{
      QueryParams: search.QueryParams{
        AroundRadius: opt.AroundRadius(1000),
      },
    },
  },
  // set validity to 30 days
  Validity: []search.TimeRange{
    {
      From:  time.Now(),
      Until: time.Now().AddDate(0, 0, 30),
    },
  },
}
res, err := index.SaveRule(rule)

Using the dashboard

Select the Search product icon on your dashboard.
Select the Rules section from the left sidebar menu in the Algolia dashboard.
Under the heading Rules, select the index you are adding a Rule to.
Select Create your first rule or New rule. In the drop-down menu, select the Manual Editor option.
In the Condition(s) section, click the Remove button with the trash can icon at the top right of the condition.
In the Consequence(s) section, click Add consequence and select Add Query Parameter.
In the input field that appears, enter the JSON search parameter you want to add followed by a colon and the value you want to add. For example: { "aroundRadius": 1000 }
In the Additional Settings, under the Timeframe in UTC header, select a time range of one month.
If you want to forward the Rule to replicas or other indices, toggle Copy this rule to other indices, and enter the relevant indices.
Save your changes.

In JSON, you must write string values inside quotation marks, and number values and booleans without quotations. To get further details on JSON syntax, checkout the record structure guidance.

Did you find this page helpful?

Adding default search parameters with Rules

On this page

Using the API

Using the dashboard

On this page