Font size:

Description:

This is a bundled training package. It contains training for each of the bundled items below:

Course Price
Form Handling with Pipelines and REST $74.95
Advanced Configuration Options $74.95
Core Commerce and the Product Catalog $74.95
Building Simple Applications $74.95
Using the Repository $74.95
Data Models and JSP $74.95
Oracle Commerce Application Structure and Deployment $74.95
Extending Oracle Commerce Applications $74.95

Bundle Price: $289.00
Total Savings: $310.60


Form Handling with Pipelines and REST

There are many ways to extend the functionality of Oracle Commerce. Knowing when and how to extend the repository form handlers is essential to support custom requirements. In this course, you will learn how to extend the platform repository form handlers to support customized functionality, control transaction boundaries programmatically, and configure and customize chains of processors that perform operations on data in a configurable sequence. This course is one of a series in the Skillsoft learning path that covers the material for the Oracle Commerce Platform Fundamentals for Developers.

Learning Objectives
  • Start the course
  • Describe how form handler components handle input from an HTML form
  • Apply property handler methods in form handlers
  • Identify the two-step process in handling form errors
  • Describe how Oracle Commerce exposes Java Transaction API (JTA) services as Nucleus components
  • Identify the methods used for transaction management
  • Identify the best practices used for writing form handlers
  • Configure and customize chains of processors that perform operations on data in a configurable sequence
  • Describe how the Oracle Commerce pipeline architecture uses processors instead of servlets
  • Identify how the Pipeline Result object is used to report errors
  • Distinguish between the Commerce Pipeline Processor classes
  • List the pipelines and the details on the processors that make them up
  • Use XML to make your custom changes to pipelines
  • Distinguish between the features of the legacy REST API and the REST MVC
  • Describe how REST MVC uses chainable components (actors)
  • Recognize how an actor helps generate a model
  • Work with XML to define an actor
  • List the attributes and elements of the actor element
  • Describe how bean filtering converts a bean into a map of properties
  • Use the bean element to define a filter for a Java bean class or interface that is in the ModelMap
  • Distinguish the differences in access control between legacy REST and REST MVC
  • Use the Administration UI to explore the Request Handling servlet pipeline configuration

Advanced Configuration Options

Oracle Commerce applications are robust and highly configurable. Advanced concepts such as custom properties, transaction management, and Oracle Commerce Principals can be applied to build rich and scalable web applications. In this course, you will learn how to add additional logic to manipulate properties, create and use new principals in the Oracle Commerce User Directory, learn transaction management, and apply your Oracle Commerce knowledge to build working applications. This course is one of a series in the Skillsoft learning path that covers the material for the Oracle Commerce Platform Fundamentals for Developers.

Learning Objectives
  • Start the course
  • Create custom property types that allow the programmatic manipulation of repository item properties
  • Distinguish between the methods for overriding and extending functions
  • Work with custom attributes to extend the functionality of an application
  • Describe how the Oracle Commerce User Directory groups users by organization and role
  • View the user principals in the ACC
  • View the organization principals in the ACC
  • View the role principals in the ACC
  • Distinguish the differences between user segments and the user directory
  • Describe how the user directory can be used to control site access with page level security
  • Describe how the user directory uses secured repositories to implement object-level security
  • Describe the concept of database transactions and database concurrency and consistency
  • Identify the ways Oracle Commerce supports JTA
  • Define the start and end points (the boundaries) of a transaction
  • Create an Oracle Commerce application module that contains a simple Java EE application
  • Override the properties of a global component with application-specific values set from the Sandbox module's local configuration layer
  • Create and configure a component based on an out-of-the-box component class
  • Register the Sandbox configuration layer and namespace with the ACC
  • Create and deploy a globally scoped component based on a custom class
  • Declare the DSP tag library for use in a JSP
  • Use standard Dynamo Servlet beans to display dynamic and conditional content on a page
  • Write a custom Dynamo Servlet bean class, and use that bean in a JSP to display conditional content

Core Commerce and the Product Catalog

Oracle Commerce comes with commerce-specific repositories as well as Core Platform repositories extended for commerce. Knowing the structure of commerce catalogs and catalog-related objects is essential to design and build Oracle Commerce applications. In this course, you will learn how product catalogs are conceptually implemented in repositories, the ways in which catalog repository data is displayed on a page, and apply SQL repository configuration skills to Commerce product catalog customizations. This course is one of a series in the Skillsoft learning path that covers the material for the Oracle Commerce Platform Fundamentals for Developers.

Learning Objectives
  • Start the course
  • Describe how Core Commerce is built on the core platform
  • Recognize how the flexible catalog hierarchy helps customize the catalog
  • Identify the properties of the Commerce Reference Store (CRS) and how it provides code, configuration, and data for simulating a complete working commerce application
  • List the item types of the product catalog repository
  • Define how category item types use navigational links for browsing
  • Recognize that SKUs are purchasable items and are associated with a particular fulfiller
  • Describe how media is a base item type in the catalog repository, which contains a reference to an image file
  • Choose the different ways to display the Oracle Commerce product catalog
  • Define the Core Commerce (DCS) and Commerce Reference Store (CRS) module structure
  • List the multiple ways to extend the catalog
  • Describe how subtypes are used when custom properties apply only to some instances of that item type
  • List the steps for extending catalog item types
  • Use profile components for a user-centered application design
  • Describe an overview of the profile repository
  • Identify the stages in the life cycle of the Profile object
  • Identify how the profile repository uses Oracle Commerce's XML file combination to construct the definition file
  • List the ways the profile repository can be modified
  • Describe how to add a business object to the profile
  • Describe how the Admin UI provides an option to view the combined XML file
  • Name the profile submission handler methods
  • Migrate the Trunk Show Repository to the MyStore module

Building Simple Applications

The Oracle Commerce Platform contains robust tools used to create rich web applications. Understanding its custom libraries and JSP usage is essential for any developer. In this course, you will be able to describe the custom beans of the Oracle Commerce Platform, create server-side Java application modules, describe the repository structure, and configure the repository. This course is one of a series in the Skillsoft learning path that covers the material for the Oracle Commerce Platform Fundamentals for Developers.

Learning Objectives
  • Start the course
  • Describe how Dynamo Servlet Beans (droplets) are used to generate page content
  • Write a simple Dynamo Servlet Bean (droplet)
  • Write a ForEach droplet to iterate over an unknown number of items in an array
  • Identify the four most frequently used Dynamo Servlet Beans
  • Describe how servlets generate dynamic content (HTML) that is returned to a JSP in response to a request
  • Describe how to create a custom servlet bean
  • Write a JSP page to accept strings, arrays, and objects
  • Recognize how a servlet bean is used to render the content specified by the page in the output open parameter
  • Describe how web applications often have many sources and forms of data
  • Describe how content repositories provide storage for content items and the ability to associate metadata with content
  • Demonstrate repository features in the ACC
  • Describe how servlet beans are used to display repository contents
  • List the ways queries can match patterns in text, query through collections, query through complex values, and specify presentation order
  • Describe how a property allows a drilldown into single and multivalue subproperties
  • Demonstrate how to combine an RQL servlet bean to an ItemLookup servlet bean
  • Describe the advantages of using the Data Anywhere Architecture to access SQL databases
  • List the properties of a repository component and know their location and functionality
  • Describe how item descriptors describe the structure of a repository item
  • Describe how enumerated properties are used and how the value is actually stored in the database
  • Identify how an item-type property can refer to an item type defined in a separate repository
  • Build two objects and define the relationship between them

Using the Repository

The Oracle Commerce Platform contains a robust repository API. Understanding how to use Java to programmatically manipulate (retrieve, create, update, delete, or query) repository data is a must for any serious application. In this course, you will be able to implement transient (non-persisted) properties, apply rules to override a property's value derivation, and configure versioned repositories and consider their use in support of Commerce Platform functionality. This course is one of a series in the Skillsoft learning path that covers the material for the Oracle Commerce Platform Fundamentals for Developers.

Learning Objectives
  • Start the course
  • Describe how the Oracle Commerce Repository API is a set of interfaces that are used for generic data access
  • Identify the classes used to view and manipulate repository elements
  • Identify the steps in creating, updating, and deleting repository items
  • Use Repository Query Language (RQL) to execute queries in a repository
  • Describe how a derived property is a transient property that derives its value from another property
  • Recognize how properties are derived and how they are defined in configuration files
  • Recognize how properties are derived from organizations and how they are defined in configuration files
  • Define the steps in setting the value of a derived property
  • List the six different derivation methods used in Oracle Commerce and describe their functionality
  • Describe how to use content administration for internally managed content such as products, images, and promotions
  • Identify the steps in creating a module used to override the application elements that differ on the CA server
  • List the differences between versioned and unversioned repositories
  • List the steps for configuring versioned repositories
  • List the steps for creating versioned tables
  • List the different utilities used to import and export data
  • Describe how hierarchical repositories are used and how they model the original file system
  • Describe how each Oracle Commerce server in a cluster maintains its own caches
  • Define the two phases performed in repository queries
  • List the six cache modes for repository items
  • Identify the differences between preloading caches, cache types, and cache invalidation
  • Review the Trunk Show Repository and supporting SQL table definitions and consider what steps would be required to add versioning

Data Models and JSP

The Oracle Commerce Platform consists of a data and presentation layer. Understanding the data relationships, and how that data is accessed is a fundamental skill for any developer. In this course, you will be able to describe the data relationships in the Oracle Commerce Platform, create data sources, describe form handling mechanisms, and write robust JSP. This course is one of a series in the Skillsoft learning path that covers the material for the Oracle Commerce Platform Fundamentals for Developers.

Learning Objectives
  • Start the course
  • Choose the collection type when working with ordered/unordered data
  • Name the Java collection types that bind keys to values
  • Identify when two items have a many-to-many relationship
  • Describe how auxiliary and multi tables are joined with the primary table
  • List the steps in setting up a test data source
  • Describe how to make your repository accessible in the ACC
  • Identify how item types can be created as subtypes of other item types
  • List the attributes of item descriptors for a subtype item
  • Identify how a composite ID is a unique ID represented by more than one column in the databasecomposite ID is a unique ID represented by more than one column in the database.
  • List the ways how grouping properties can improve performance
  • Describe how to configure cascading relationships
  • Describe the mechanism Oracle Commerce uses for handling forms
  • Specify how Oracle Commerce normally accesses properties of beans
  • Configure fields of a form page by associating them with the properties of the form handler
  • Specify how to provide methods to select from an enumerated list of possible options
  • List the methods that can be called on submission to process the data in a form
  • Write a JSP page using form page redirection to set the action page back to the form page
  • List the properties RepositoryFormHandler uses to help manage form errors
  • Describe how form submission and handling occurs, and how request-scoped form handlers work
  • Describe how form handlers know which item in the repository to update
  • Build a JSP form using collections, tag, and error handling

Oracle Commerce Application Structure and Deployment

Since the Oracle Commerce Platform consists of such a broad range of technologies, understanding its application structure and deployment is essential for any developer. In this course, you will be able to describe the features and capabilities of the Oracle Commerce Platform, create an Oracle Commerce Platform application module, and deploy Oracle Commerce Platform applications. This course is one of a series in the Skillsoft learning path that covers the material for the Oracle Commerce Platform Fundamentals for Developers.

Learning Objectives
  • Start the course
  • Describe the features and capabilities that the Oracle Commerce Platform provides for online commerce solution development
  • Distinguish between core concepts of a Repository, Profile, and Scenario
  • Identify the development tools, file and folder structure, configuration files, and application modules
  • List the steps needed to assemble, deploy, and run Oracle Commerce Platform applications
  • Describe the several methods for creating an EAR for your application
  • Instantiate and configure standard nucleus components
  • Set up properties files and component configuration
  • Describe how Oracle Commerce uses environment variables and configuration layering
  • List important types of layers as set by the config path
  • Describe how sessions are special server-side objects corresponding to different users or browsers
  • Examine application log files and configure component logging levels
  • Create, configure, and deploy a session-scoped component
  • List the types of custom component classes and where they are used
  • Describe how to reference custom components within a Java program
  • Create a Java class in Eclipse, browse to find the superclass, and import classes and packages
  • Describe the basics on the JSP syntax and use JSP tags
  • Perform the steps needed for Eclipse to include the DSP and DSPEL tag libraries
  • Describe how importing a component allows access to its properties by a simple name rather than the full component path
  • Write a simple, completely static JSP page
  • Write a program to pass values into an embedded JSP page
  • Use Eclipse in collaboration with tag libraries to build and integrate an Oracle Commerce application

Extending Oracle Commerce Applications

The Oracle Commerce Platform provides the developer with a full-featured framework to build web applications. To master Oracle Commerce, it is important that you know how to extend applications' capabilities. In this course, you will create and configure a SQL repository, configure a repository so that items are preloaded upon repository startup, and other essential tasks for extending Oracle Commerce applications. This course is one of a series in the Skillsoft learning path that covers the material for the Oracle Commerce Platform Fundamentals for Developers.

Learning Objectives
  • Start the course
  • Work with the Profile Adapter Repository
  • Create and configure a SQL repository
  • Create a subtype of an item descriptor, create items of that subtype, and optionally display the unique subtype properties on a page
  • Use the Repository Form Handler to add, modify, and delete repository items
  • Use the Repository programming interface to programmatically manipulate repository data within Java code
  • Configure a repository definition to implement an overridable derived property
  • Consider the steps required to add version capability to a SQL repository
  • Configure a repository so that items are preloaded upon repository startup
  • Start the Commerce Reference Store server, explore the storefront, and take a close look at the Product Catalog
  • Configure Eclipse to manage your Commerce Reference Store development work
  • Extend the catalog by adding a custom property to the product repository item definition
  • Add a property to the user profile definition
  • Update the user details page, displaying an additional profile property
  • Create a custom form handler and use that form on a page
  • Use the Administration UI and the ACC to explore Oracle Commerce pipeline configurations
  • Build and deploy a completed Oracle Commerce application
Register Now
Oracle Commerce: Platform Fundamentals e-learning bundle
  • Course ID:
    271462
  • Duration:
    n/a
  • Price:
    $289