# Using logical statements (JsonLogic)

In manifest [JsonLogic](http://jsonlogic.com/) is used for visibility and disabled conditions, for figuring out next screen user needs to be taken and in request data transformers.

```typescript
interface JsonLogic {
  type: "jsonlogic";
  schema: JsonLogic;
}
```

JsonLogic can access variables ([more info](http://jsonlogic.com/operations.html#var)). The following namespaces are available:

## Available Namespaces

| Namespace          | Description                                                       | Example                                 |
| ------------------ | ----------------------------------------------------------------- | --------------------------------------- |
| `input.*`          | User input fields                                                 | `{"var": "input.data.field"}`           |
| `input.first_name` | Hardcoded fields (no data. prefix)                                | `{"var": "input.first_name"}`           |
| `flags.*`          | Framework flags                                                   | `{"var": "flags.editing"}`              |
| `quote.*`          | Quote response data                                               | `{"var": "quote.gross_payment_amount"}` |
| `policy.*`         | Policy response data                                              | `{"var": "policy.publicId"}`            |
| `claim.*`          | Claim response data (FNOL)                                        | `{"var": "claim.id"}`                   |
| `lead.*`           | Lead data                                                         | `{"var": "lead.email"}`                 |
| `item.*`           | Item/product data                                                 | `{"var": "item.id"}`                    |
| `dataset.*`        | Dataset items (see [dataset namespace](#dataset-namespace) below) | `{"var": "dataset.data.company.name"}`  |
| `asset.*`          | Asset URLs                                                        | `{"var": "asset.logo"}`                 |
| `document.*`       | Document data                                                     | `{"var": "document.lead.offer.url"}`    |
| `route.*`          | Current route/screen                                              | `{"var": "route.path"}`                 |
| `query_string.*`   | URL query parameters                                              | `{"var": "query_string.ref"}`           |
| `context.*`        | Repeater context                                                  | `{"var": "context.repeater_index"}`     |
| `form.*`           | Form state                                                        | `{"var": "form.has_errors"}`            |
| `active_policy.*`  | Active policy in FNOL                                             | `{"var": "active_policy.id"}`           |
| `renewal.*`        | Policy renewal data                                               | `{"var": "renewal.id"}`                 |

**Important**: `flags` is a top-level namespace, NOT under `input`.

* Correct: `{"var": "flags.editing"}`
* Wrong: `{"var": "input.flags.editing"}`

For a complete list of available flags, see the [visibility condition guide](/kasko-frontend-documentation/core-concepts/visibility-condition.md).

## Dataset Namespace

The `dataset` namespace provides access to loaded dataset items. Dataset items are loaded when a field with the `in_dataset` validation rule has a value.

### Structure

```
dataset.{field_name}.{property}
```

* `{field_name}` - The form field name that holds the dataset item ID (e.g., `data.company`, `data.location`)
* `{property}` - Any property from the dataset item

### Dataset Item Properties

Every loaded dataset item has:

* `id` - The dataset item ID (e.g., `dai_abc123...`)
* `dataset_id` - The dataset ID (e.g., `dat_xyz789...`)
* Plus any custom fields defined in the dataset

### Examples

```json
// Access a dataset field
{"var": "dataset.data.company.name"}

// Access nested properties
{"var": "dataset.data.company.address.city"}

// Check if dataset is loaded
{"!!": [{"var": "dataset.data.company"}]}

// Compare dataset values
{"===": [{"var": "dataset.data.company.country"}, "DE"]}

// Use in visibility condition
{
  "visibility_condition": {
    "type": "jsonlogic",
    "schema": {
      "===": [{"var": "dataset.data.company.type"}, "enterprise"]
    }
  }
}
```

### With Repeaters

For repeater fields, include the index in the path:

```json
// Access dataset for first agent's location
{"var": "dataset.data.agents.0.location.city"}

// Dynamic access using cat operator
{"var": {"cat": ["dataset.data.agents.", {"var": "context.repeater_index"}, ".location.city"]}}
```

## Custom operators

### `iso_date`

It takes in `Date` object and returns ISO String of it. If value passed in is not `Date` object, there will be a warning message and output will be untouched value that was passed in.

This is useful when input has Date object, but some operations have to be made with this value using JsonLogic (e.g. `substr` to get year, month, day etc.).

| Logic                            | Date                   | Result         |
| -------------------------------- | ---------------------- | -------------- |
| `{ "iso_date": {"var":"date"} }` | `{ date: new Date() }` | `"2019-06-11"` |

This operator can also accept modifier value as a second (optional) parameter, that is a string.

| Logic                                                                  | Date                   | Result         |
| ---------------------------------------------------------------------- | ---------------------- | -------------- |
| `{ "iso_date": [{"var":"date"}, "-5 days"}`                            | `{ date: new Date() }` | `"2019-06-06"` |
| `{ "iso_date": [{"var":"date"}, "+1 month"}`                           | `{ date: new Date() }` | `"2019-07-11"` |
| `{ "iso_date": [{ "iso_date": [{"var":"date"}, "+2 years"}, "-1 day"}` | `{ date: new Date() }` | `"2021-06-10"` |

### `length`

Returns length of array.

| Logic                                     | Input                          | Result |
| ----------------------------------------- | ------------------------------ | ------ |
| `{ "length": { "var": "input.numbers" }}` | `{ numbers: ['a', 'b', 'c'] }` | `3`    |

### `to_object`

Builds object from flat entries list.

| Logic                                 | Input | Result                 |
| ------------------------------------- | ----- | ---------------------- |
| `{"to_object": ["foo", 1, "bar", 2]}` | ...   | `{"foo": 1, "bar": 2}` |

### `path`

Has ability to access context from string.

Let's say you have repeater component and in there you must have ability to show/hide field with jsonlogic based on value on particular field in repeater array. We can use `path` operator in combination with `var` to do so.

With data:

```json
{
  "agents": [
    {
      "name": "John"
    },
    {
      "name": "Jane"
    },
    {
      "name": "Alfred"
    }
  ]
}
```

| Logic                                               | Context                 | Result            |
| --------------------------------------------------- | ----------------------- | ----------------- |
| `{"path": "agents.{repeater_index}.name"}`          | `{ repeater_index: 2 }` | `"agents.2.name"` |
| `{"var": {"path": "agents.{repeater_index}.name"}}` | `{ repeater_index: 2 }` | `"Alfred"`        |


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.kasko.io/kasko-frontend-documentation/guides/jsonlogic.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.