CortexClientFactory provides the Cortex client instance. To obtain an new Cortex client instant, inject the Factory and pass in a MultiValuedMap with the header and the scope (the store code) to the factory.

			@Reference
			com.elasticpath.rest.client.CortexClientFactory clientFactory;
			...
			MultivaluedMap<String, Object> headers = new MultivaluedHashMap<String, Object>();
			headers.putSingle(HeaderKeys.X_EP_USER_ID_KEY, "customerId");
			headers.putSingle(HeaderKeys.X_EP_USER_ROLES_KEY, "PUBLIC");
			headers.putSingle(HeaderKeys.AUTHORIZATION_KEY, "authToken");
			com.elasticpath.rest.client.CortexClient client = clientFactory.create(headers, scope);

To use the Cortex client in a non-OSGi environment, you need to manually instantiate the required beans. The following example shows how to use a Spring application context with the Cortex client.

				<?xml version="1.0" encoding="UTF-8"?>
				<beans
						xmlns="http://www.springframework.org/schema/beans"
						xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
						xsi:schemaLocation="http://www.springframework.org/schema/beans
                                                http://www.springframework.org/schema/beans/spring-beans-4.0.xsd">

					<bean id="jacksonObjectMapper" class="com.elasticpath.example.ApplicationObjectMapper" init-method="init"/commerce-legacy/>
					<!-- Note that this is a custom com.fasterxml.jacson.databind.ObjectMapper extension which disables the
					FAIL_ON_UNKNOWN_PROPERTIES on initialization. this.disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES) -->
					<bean id="jsonUnmarshaller" class="com.fasterxml.jackson.contrib.jsonpath.DefaultJsonUnmarshaller"/commerce-legacy/>
					<bean id="zoomModelIntrospector" class="com.elasticpath.rest.client.urlbuilding.zoom.ZoomModelIntrospector"/commerce-legacy/>
					<bean id="zoomQueryFactory" class="com.elasticpath.rest.client.urlbuilding.zoom.ZoomQueryFactory"/commerce-legacy/>
					<bean id="cortexUrlFactoryImpl" class="com.elasticpath.rest.client.urlbuilding.impl.CortexUrlFactoryImpl">
						<constructor-arg ref="zoomModelIntrospector"/commerce-legacy/>
						<constructor-arg ref="zoomQueryFactory"/commerce-legacy/>
					</bean>
					<bean id="jacksonProvider"  class="com.elasticpath.rest.client.unmarshalling.JacksonProvider" >
						<constructor-arg ref="jacksonObjectMapper"/commerce-legacy/>
					</bean>
					<bean id="jsonUnmarshallReaderInterceptor" class="com.elasticpath.rest.client.unmarshalling.JsonUnmarshallReaderInterceptor">
						<constructor-arg ref="jsonUnmarshaller"/commerce-legacy/>
					</bean>
				</beans>
			

				...
				public CortexClientFactory exampleCortexClientFactorySetup(final ApplicationContext context) {
					ClientConfig clientConfig = new ClientConfig();
					clientConfig.register(new WebApplicationExceptionMapper())
							.register(jacksonProvider)
							.register(jsonUnmarshallReaderInterceptor)
							.register(new LoggingFilter(Logger.getLogger(App.class.getName()), true)) // Should be configurable at runtime
							.property(ClientProperties.CONNECT_TIMEOUT, CONNECT_TIMEOUT)  // Should be configurable at runtime
							.property(ClientProperties.READ_TIMEOUT, READ_TIMEOUT); // Should be configurable at runtime
					//Real implementation will want to pass configurable values to this builder.
					HttpClientConfigurator httpClientConfigurator = new HttpClientConfiguratorBuilder().build();
					httpClientConfigurator.configure(clientConfig);
					Client jaxRsClient = ClientBuilder.newClient(clientConfig);
					CortexUrlFactory cortexUrlFactory = (CortexUrlFactory) context.getBean("cortexUrlFactoryImpl");
					//Cortex url should be configurable at runtime.
					return new CortexClientFactoryImpl(cortexUrlFactory, jaxRsClient, "http://localhost:9080/cortex/");
				}
			

@Zoom(@Path("order"))
@FollowLocation
public class Cart {}

URLs with Zoom or FollowLocation query parameters can be constructed by calling the createResourceUrlWithQueryParameters method:

baseUrl = "http://localhost:9080/cortex/"
path = "carts/mobee/default"
result = cortexUrlFactory.addQueryParametersToResourceUrl(baseUrl, path, Cart.class)
//result = "http://localhost:9080/cortex/carts/mobee/default?zoom=order&followLocation=true"

URLs without query parameters can be constructed by calling the createResourceUrl method:

baseUrl = "http://localhost:9080/cortex/"
path = "carts/mobee/default"
result = cortexUrlFactory.createResourceUrl(baseUrl, path)
//result = "http://localhost:9080/cortex/carts/mobee/default"

@EntryPointUri(“carts/{scope}/default”)
@Zoom(@Path("lineitems"))
@FollowLocation
public class Carts {}

URLs using entry point URIs can be constructed by calling the createResourceUrlFromAnnotations method:

baseUrl = “http://localhost:9080/cortex/”
store = “mobee”
result = cortexUrlFactory.createResourceUrlFromAnnotations(baseUrl, store, Carts.class)
//result = "http://localhost:9080/cortex/carts/mobee/default?zoom=lineitems&followLocation=true" 

Extract a single, non-nested, JSON property:

public class Cart {)
  @JsonProperty("total-quantity")
  private String totalQuantity;
}

Extract nested JSON properties:

public class Cart {
  //Non-nested JSON property
  @JsonPath("$.total-quantity")
  private int totalQuantity;

  //Nested Property
  @JsonPath("$._lineitems[0]._element[0].quantity")
  private int quantity;

  //Nested Array 
  @JsonPath("$._lineitems[0]._element")
  private List<LineItem> lineItems;
}