---
apiVersion: v1
kind: ConfigMap
metadata:
  labels:
    funktion.fabric8.io/kind: Connector
  name: velocity
data:
  deployment.yml: |
    ---
    apiVersion: extensions/v1beta1
    kind: Deployment
    metadata:
      labels:
        funktion.fabric8.io/kind: Subscription
        connector: velocity
    spec:
      replicas: 1
      template:
        metadata:
          labels:
            funktion.fabric8.io/kind: Subscription
            connector: velocity
        spec:
          containers:
          - image: funktion/connector-velocity:${project.version}
            name: connector
  schema.yml: |
    ---
    component:
      kind: component
      scheme: velocity
      syntax: velocity:resourceUri
      title: Velocity
      description: Transforms the message using a Velocity template.
      label: transformation
      deprecated: false
      async: false
      producerOnly: true
      javaType: org.apache.camel.component.velocity.VelocityComponent
      groupId: org.apache.camel
      artifactId: camel-velocity
      version: 2.18.3
    componentProperties:
      velocityEngine:
        kind: property
        type: object
        javaType: org.apache.velocity.app.VelocityEngine
        deprecated: false
        secret: false
        description: To use the VelocityEngine otherwise a new engine is created
        order: 0
    properties:
      resourceUri:
        kind: path
        group: producer
        required: true
        type: string
        javaType: java.lang.String
        deprecated: false
        secret: false
        description: Path to the resource or a reference to lookup a bean in the Registry to use as the resource
        order: 0
      contentCache:
        kind: parameter
        group: producer
        type: boolean
        javaType: boolean
        deprecated: false
        secret: false
        defaultValue: false
        description: Sets whether to use resource content cache or not
        order: 1
      encoding:
        kind: parameter
        group: producer
        type: string
        javaType: java.lang.String
        deprecated: false
        secret: false
        description: Character encoding of the resource content.
        order: 2
      loaderCache:
        kind: parameter
        group: producer
        type: boolean
        javaType: boolean
        deprecated: false
        secret: false
        defaultValue: true
        description: Enables / disables the velocity resource loader cache which is enabled by default
        order: 3
      propertiesFile:
        kind: parameter
        group: producer
        type: string
        javaType: java.lang.String
        deprecated: false
        secret: false
        description: The URI of the properties file which is used for VelocityEngine initialization.
        order: 4
      synchronous:
        kind: parameter
        group: advanced
        label: advanced
        type: boolean
        javaType: boolean
        deprecated: false
        secret: false
        defaultValue: false
        description: Sets whether synchronous processing should be strictly used or Camel is allowed to use asynchronous processing (if supported).
        order: 5
  documentation.adoc: |+
    [[Velocity-Velocity]]
    Velocity
    ~~~~~~~~

    The *velocity:* component allows you to process a message using an
    http://velocity.apache.org/[Apache Velocity] template. This can be ideal
    when using link:templating.html[Templating] to generate responses for
    requests.

    Maven users will need to add the following dependency to their `pom.xml`
    for this component:

    [source,xml]
    ------------------------------------------------------------
    <dependency>
        <groupId>org.apache.camel</groupId>
        <artifactId>camel-velocity</artifactId>
        <version>x.x.x</version>
        <!-- use the same version as your Camel core version -->
    </dependency>
    ------------------------------------------------------------

    [[Velocity-URIformat]]
    URI format
    ^^^^^^^^^^

    [source,java]
    -------------------------------
    velocity:templateName[?options]
    -------------------------------

    Where *templateName* is the classpath-local URI of the template to
    invoke; or the complete URL of the remote template (eg:
    file://folder/myfile.vm[file://folder/myfile.vm]).

    You can append query options to the URI in the following format,
    `?option=value&option=value&...`

    [[Velocity-Options]]
    Options
    ^^^^^^^



    // component options: START
    The Velocity component supports 1 options which are listed below.



    {% raw %}
    [width="100%",cols="2,1m,7",options="header"]
    |=======================================================================
    | Name | Java Type | Description
    | velocityEngine | VelocityEngine | To use the VelocityEngine otherwise a new engine is created
    |=======================================================================
    {% endraw %}
    // component options: END




    // endpoint options: START
    The Velocity component supports 6 endpoint options which are listed below:

    {% raw %}
    [width="100%",cols="2,1,1m,1m,5",options="header"]
    |=======================================================================
    | Name | Group | Default | Java Type | Description
    | resourceUri | producer |  | String | *Required* Path to the resource or a reference to lookup a bean in the Registry to use as the resource
    | contentCache | producer | false | boolean | Sets whether to use resource content cache or not
    | encoding | producer |  | String | Character encoding of the resource content.
    | loaderCache | producer | true | boolean | Enables / disables the velocity resource loader cache which is enabled by default
    | propertiesFile | producer |  | String | The URI of the properties file which is used for VelocityEngine initialization.
    | synchronous | advanced | false | boolean | Sets whether synchronous processing should be strictly used or Camel is allowed to use asynchronous processing (if supported).
    |=======================================================================
    {% endraw %}
    // endpoint options: END


    [[Velocity-MessageHeaders]]
    Message Headers
    ^^^^^^^^^^^^^^^

    The velocity component sets a couple headers on the message (you can't
    set these yourself and from Camel 2.1 velocity component will not set
    these headers which will cause some side effect on the dynamic template
    support):

    [width="100%",cols="10%,90%",options="header",]
    |=======================================================================
    |Header |Description

    |`CamelVelocityResourceUri` |The *templateName* as a `String` object.

    |`CamelVelocitySupplementalContext` |*Camel 2.16:* To add additional information to the used VelocityContext.
    The value of this header should be a `Map` with key/values that will
    added (override any existing key with the same name). +
    This can be used to pre setup some common key/values you want to reuse
    in your velocity endpoints.
    |=======================================================================

    Headers set during the Velocity evaluation are returned to the message
    and added as headers. Then its kinda possible to return values from
    Velocity to the Message.

    For example, to set the header value of `fruit` in the Velocity template
    `.tm`:

    [source,java]
    -------------------------------
    $in.setHeader("fruit", "Apple")
    -------------------------------

    The `fruit` header is now accessible from the `message.out.headers`.

    [[Velocity-VelocityContext]]
    Velocity Context
    ^^^^^^^^^^^^^^^^

    Camel will provide exchange information in the Velocity context (just a
    `Map`). The `Exchange` is transfered as:

    [width="100%",cols="10%,90%",options="header",]
    |=======================================================================
    |key |value

    |`exchange` |The `Exchange` itself.

    |`exchange.properties` |The `Exchange` properties.

    |`headers` |The headers of the In message.

    |`camelContext` |The Camel Context instance.

    |`request` |The In message.

    |`in` |The In message.

    |`body` |The In message body.

    |`out` |The Out message (only for InOut message exchange pattern).

    |`response` |The Out message (only for InOut message exchange pattern).
    |=======================================================================

    Since Camel-2.14, you can setup a custom Velocity Context yourself by
    setting the message header *CamelVelocityContext *just like this

    [source,java]
    -----------------------------------------------------------------------
       VelocityContext velocityContext = new VelocityContext(variableMap);
       exchange.getIn().setHeader("CamelVelocityContext", velocityContext);
    -----------------------------------------------------------------------

     

    [[Velocity-Hotreloading]]
    Hot reloading
    ^^^^^^^^^^^^^

    The Velocity template resource is, by default, hot reloadable for both
    file and classpath resources (expanded jar). If you set
    `contentCache=true`, Camel will only load the resource once, and thus
    hot reloading is not possible. This scenario can be used in production,
    when the resource never changes.

    [[Velocity-Dynamictemplates]]
    Dynamic templates
    ^^^^^^^^^^^^^^^^^

    *Available as of Camel 2.1* +
     Camel provides two headers by which you can define a different resource
    location for a template or the template content itself. If any of these
    headers is set then Camel uses this over the endpoint configured
    resource. This allows you to provide a dynamic template at runtime.

    [width="100%",cols="10%,10%,80%",options="header",]
    |=======================================================================
    |Header |Type |Description

    |CamelVelocityResourceUri |String |*Camel 2.1:* A URI for the template resource to use instead of the
    endpoint configured.

    |CamelVelocityTemplate |String |*Camel 2.1:* The template to use instead of the endpoint configured.
    |=======================================================================

    [[Velocity-Samples]]
    Samples
    ^^^^^^^

    For example you could use something like

    [source,java]
    ----------------------------------------
    from("activemq:My.Queue").
      to("velocity:com/acme/MyResponse.vm");
    ----------------------------------------

    To use a Velocity template to formulate a response to a message for
    InOut message exchanges (where there is a `JMSReplyTo` header).

    If you want to use InOnly and consume the message and send it to another
    destination, you could use the following route:

    [source,java]
    ----------------------------------------
    from("activemq:My.Queue").
      to("velocity:com/acme/MyResponse.vm").
      to("activemq:Another.Queue");
    ----------------------------------------

    And to use the content cache, e.g. for use in production, where the
    `.vm` template never changes:

    [source,java]
    ----------------------------------------------------------
    from("activemq:My.Queue").
      to("velocity:com/acme/MyResponse.vm?contentCache=true").
      to("activemq:Another.Queue");
    ----------------------------------------------------------

    And a file based resource:

    [source,java]
    -----------------------------------------------------------------
    from("activemq:My.Queue").
      to("velocity:file://myfolder/MyResponse.vm?contentCache=true").
      to("activemq:Another.Queue");
    -----------------------------------------------------------------

    In *Camel 2.1* it's possible to specify what template the component
    should use dynamically via a header, so for example:

    [source,java]
    ---------------------------------------------------------------------------
    from("direct:in").
      setHeader("CamelVelocityResourceUri").constant("path/to/my/template.vm").
      to("velocity:dummy");
    ---------------------------------------------------------------------------

    In *Camel 2.1* it's possible to specify a template directly as a header
    the component should use dynamically via a header, so for example:

    [source,java]
    ---------------------------------------------------------------------------------------------------------------
    from("direct:in").
      setHeader("CamelVelocityTemplate").constant("Hi this is a velocity template that can do templating ${body}").
      to("velocity:dummy");
    ---------------------------------------------------------------------------------------------------------------

    [[Velocity-TheEmailSample]]
    The Email Sample
    ^^^^^^^^^^^^^^^^

    In this sample we want to use Velocity templating for an order
    confirmation email. The email template is laid out in Velocity as:

    [source,java]
    ----------------------------------------------
    Dear ${headers.lastName}, ${headers.firstName}

    Thanks for the order of ${headers.item}.

    Regards Camel Riders Bookstore
    ${body}
    ----------------------------------------------

    And the java code:

    [[Velocity-SeeAlso]]
    See Also
    ^^^^^^^^

    * link:configuring-camel.html[Configuring Camel]
    * link:component.html[Component]
    * link:endpoint.html[Endpoint]
    * link:getting-started.html[Getting Started]

