// THIS FILE IS AUTOMATICALLY GENERATED: DO NOT EDIT
= image:kamelets/predicate-filter-action.svg[] Predicate Filter Action

*Provided by: "Apache Software Foundation"*

*Support Level for this Kamelet is: "Preview"*

Filter based on a JsonPath Expression

== Configuration Options

The following table summarizes the configuration options available for the `predicate-filter-action` Kamelet:
[width="100%",cols="2,^2,3,^2,^2,^3",options="header"]
|===
| Property| Name| Description| Type| Default| Example
| *expression {empty}* *| Expression| The JsonPath Expression to evaluate, without the external parenthesis. Since this is a filter, the expression will be a negation, this means that if the foo field of the example is equals to John, the message will go ahead, otherwise it will be filtered out.| string| | `"@.foo =~ /.*John/"`
|===

NOTE: Fields marked with ({empty}*) are mandatory.

== Usage

This section summarizes how the `predicate-filter-action` can be used in various contexts.

=== Knative Action

The `predicate-filter-action` Kamelet can be used as intermediate step in a Knative binding.

.predicate-filter-action-binding.yaml
[source,yaml]
----
apiVersion: camel.apache.org/v1alpha1
kind: KameletBinding
metadata:
  name: predicate-filter-action-binding
spec:
  source:
    ref:
      kind: Kamelet
      apiVersion: camel.apache.org/v1alpha1
      name: timer-source
    properties:
      message: "Hello"
  steps:
  - ref:
      kind: Kamelet
      apiVersion: camel.apache.org/v1alpha1
      name: predicate-filter-action
    properties:
      expression: "@.foo =~ /.*John/"
  sink:
    ref:
      kind: InMemoryChannel
      apiVersion: messaging.knative.dev/v1
      name: mychannel

----
Make sure you have xref:latest@camel-k::installation/installation.adoc[Camel K installed] into the Kubernetes cluster you're connected to.

Save the `predicate-filter-action-binding.yaml` file into your hard drive, then configure it according to your needs.

You can run the action using the following command:

[source,shell]
----
kubectl apply -f predicate-filter-action-binding.yaml
----

==== *Dependencies*

The Kamelet needs the following dependencies:


- camel:core
- camel:kamelet
- camel:jsonpath 

==== *Binding to Knative using the Kamel CLI:*

The procedure described above can be simplified into a single execution of the `kamel bind` command:

[source,shell]
----
kamel bind timer-source?message=Hello --step predicate-filter-action -p "step-0.expression=@.foo =~ /.*John/" channel/mychannel
----

This will create the KameletBinding under the hood and apply it to the current namespace in the cluster.

=== Kafka Action

The `predicate-filter-action` Kamelet can be used as intermediate step in a Kafka binding.

.predicate-filter-action-binding.yaml
[source,yaml]
----
apiVersion: camel.apache.org/v1alpha1
kind: KameletBinding
metadata:
  name: predicate-filter-action-binding
spec:
  source:
    ref:
      kind: Kamelet
      apiVersion: camel.apache.org/v1alpha1
      name: timer-source
    properties:
      message: "Hello"
  steps:
  - ref:
      kind: Kamelet
      apiVersion: camel.apache.org/v1alpha1
      name: predicate-filter-action
    properties:
      expression: "@.foo =~ /.*John/"
  sink:
    ref:
      kind: KafkaTopic
      apiVersion: kafka.strimzi.io/v1beta1
      name: my-topic

----

Ensure that you've installed https://strimzi.io/[Strimzi] and created a topic named `my-topic` in the current namespace.
Make also sure you have xref:latest@camel-k::installation/installation.adoc[Camel K installed] into the Kubernetes cluster you're connected to.

Save the `predicate-filter-action-binding.yaml` file into your hard drive, then configure it according to your needs.

You can run the action using the following command:

[source,shell]
----
kubectl apply -f predicate-filter-action-binding.yaml
----

==== *Binding to Kafka using the Kamel CLI:*

The procedure described above can be simplified into a single execution of the `kamel bind` command:

[source,shell]
----
kamel bind timer-source?message=Hello --step predicate-filter-action -p "step-0.expression=@.foo =~ /.*John/" kafka.strimzi.io/v1beta1:KafkaTopic:my-topic
----

This will create the KameletBinding under the hood and apply it to the current namespace in the cluster.

// THIS FILE IS AUTOMATICALLY GENERATED: DO NOT EDIT
