1. Implementation Guide
  2. Integration with Merchandising

4 Integration with Merchandising

This chapter describes the various integrations between Retail Merchandising Foundation Cloud Services (RMFCS) and the Retail Analytics and Planning platform. RMFCS can be used as the primary source of foundation data for RAP and pre-built integrations and batch programs exist to move data between cloud applications. You may also use an on-premise installation of the Retail Merchandising System (RMS), in which case you must establish the integration to the RAP cloud following the guidance in this chapter.

Architecture Overview

In prior releases, the integration between RMFCS and RI/AIF used a tool named the Retail Data Extractor (RDE) to generate data files for RI/AIF to consume. These programs have been fully integrated to the RAP batch flow and directly insert the data from RMFCS to RAP. The integration uses an instance of Oracle Golden Gate to copy RMFCS tables to the local database, where the Data Extractor jobs can source all required data and transform it for use in RAP. If you are familiar with the prior RDE architecture, then you need to be aware of the following major changes:

  1. RDE_DM01 database objects are now located in the RADM01 schema. RDE_RMS01 database objects are now in the RABE01USER schema. The RABE01USER now has access to extract records from RMFCS through the Golden Gate replicated schema.

  2. The C_ODI_PARAM configuration tables have been merged and all RDE configurations are accessed from the Control & Tactical Center.

  3. File-based integration has been removed. All data is moved directly between database source and target tables with no option to produce flat files.

  4. RDE’s batch schedule has been merged with RI’s schedule in POM. Jobs have been renamed and assigned modules such that it is easy to identify and disable/enable RDE jobs as needed.

  5. Customer Engagement (CE) integration jobs have been included in RDE for when CE is set up to replicate data to RAP. File-based integration is no longer required.

  6. All jobs relating to file extraction, ZIP file creation, or data cleanup in RMS have been removed.

Because RDE jobs are now a part of the RAP nightly batch cycle, they have been assigned modules in the Customer Modules framework (accessed using Retail Home) and can be enabled or disabled in bulk depending on your use-cases.

  • RDE_RMS – These are the RDE components in relation to RMS

  • RDE_CE – These are the RDE components in relation to CE

If you are not integrating data from RMFCS or CE then you will need to disable these modules to prevent them from running in your nightly batch cycles. RI and AIF jobs are programmed to start automatically after the RDE jobs complete, but if the RDE jobs are disabled then the dependencies will be ignored.

Batch Schedule Configuration

Although the RDE programs are integrated with the overall RAP schedule, the way you manage the POM processes for it is different. The RDE jobs have pre-defined dependencies with RI as well as inter-schedule dependencies with RMFCS. When you enable the RDE jobs, the dependencies with RI/AIF will be enabled automatically but you will need to manually enable/disable the RMFCS dependencies based on your needs.

In general, you should start with all dependencies enabled, and only disable them if you are trying to run the batch cycle out of sync from the RMFCS batch. The inter-schedule dependencies fall into two categories: discreet jobs that perform some check on RMFCS data, and POM dependencies that cross-reference another RMFCS batch program. The first category of jobs check the availability of data from the RMFCS signaling table called RMS_RDE_BATCH_STATUS. The RDE jobs that checks the signaling table in RMS are:

  1. RDE_INTERSCHED_CHECK_RESAEXTRACT_PROCESS / RDE_INTERSCHED_CHECK_RESAEXTRACT_JOB - Checks the completion of the RESA_EXTRACT job in RMFCS

  2. RDE_INTERSCHED_CHECK_INVSNAPSHOT_PROCESS / RDE_INTERSCHED_CHECK_INVSNAPSHOT_JOB - Checks the completion of the INVENTORY_SNAPSHOT job that signifies that the ITEM_LOC_SOH_EOD table in RMS is now available for RDE extract

  3. RDE_INTERSCHED_CHECK_STAGETRANDATA_PROCESS / RDE_INTERSCHED_CHECK_STAGETRANDATA_JOB - Checks the completion of the STAGE_TRAN_DATA job that signifies that the IF_TRAN_DATA table in RMFCS is now available for RDE extract

The second category of dependencies are found on the RDE jobs themselves, when you click on a job to view its details in POM. These jobs are listed below along with the RMFCS jobs they depend on.

  1. CSTISLDSDE_PROCESS / CSTISLDSDE_JOB – This RDE job waits for the following RMFCS jobs to complete:

    • ALLOCBT_PROCESS / ALLOCBT_JOB

    • BATCH_RFMCURRCONV_PROCESS / BATCH_RFMCURRCONV_JOB

    • COSTCOMPUPD_ELCEXPRG_PROCESS / ELCEXCPRG_JOB

    • EDIDLCON_PROCESS / EDIDLCON_JOB

    • EXPORT_STG_PURGE_PROCESS / EXPORT_STG_PURGE_JOB

    • EDIUPAVL_PROCESS / EDIUPAVL_JOB

    • LIKESTOREBATCH_PROCESS / LIKESTOREBATCH_JOB

    • POSCDNLD_PROCESS / POSCDNLD_POST_JOB

    • REPLINDBATCH_PROCESS / REPLINDBATCH_JOB

    • SALESPROCESS_PROCESS / SALESUPLOADARCH_JOB

    • STKVAR_PROCESS / STKVAR_JOB

  2. RDEBATCH_INITIAL_START_PROCESS / RDEBATCH_INITIAL_START_MILEMARKER_JOB – This RDE job waits for the RMFCS job STOP_RIB_ADAPTOR_INV_PROCESS / STOP_RIB_ADAPTOR_INV_JOB to complete.

Aside from the dependencies, the RDE jobs have also been labeled and categorized by their primary purpose, so you can easily identify jobs you may want to enable or disable for your implementation. The bulk of the RDE jobs are divided into two main classifications, which are dimension jobs (those with RDE_EXTRACT_DIM_* in their job names) and fact jobs (those with RDE_EXTRACT_FACT_* in their job names). They are also grouped into execution phases based on their functional usage, as described in the tables below. The phases are all run in parallel to each other and don’t have dependencies between them, they are purely for ease of use.

Table 4-1 RDE Dimension Phases

DIMENSION PHASE No. GROUPING FACTOR

P1

Consists of dimension jobs that populate the GRP1, GRP2, and GRP3 staging tables

P2

Consists of the Security jobs (RAF table entries)

P3

Consists of dimension jobs related to the item (for example, Merch hierarchy, item charges, item season, RDW_DELETE*)

P4

Consists of dimension jobs related to Custom Flex Attributes (CFA)

P5

Consists of dimension jobs related to Replenishment

P6

Consists of dimension jobs related to Merch Organization Hierarchy (for example, location list, location traits, organization financial information, and so on)

P7

Consists of dimension jobs related to Transfers (for example, transfer details, transfer charges, and so on)

P8

Consists of dimension jobs related to extract of codes used by Merchandising (for example, Inventory Adjustment reasons, Inventory status types, codes, and so on)

P9

Consists of dimension jobs related to the supplier (for example, supplier traits, supplier information, and so on)

P10

Consists of dimension jobs related to Purchase Orders (for example, PO Details, Shipment Details, ELC, and so on)

P11

Consists of dimension jobs related to allocation (for example, Allocation detail, allocation charges, and so on)

P12

Consists of dimension jobs related to Merchandising Calendar information

P13

Consists of dimension jobs related to Merchandising promotions

P14

Consists of dimension jobs related to employee information

P15

Consists of dimension jobs related to competitor information

P16

Consists of dimension jobs related to Merchandising Parameter tables (*_GS).

P17

Consists of dimension jobs related to buyer information

P18

Consists of Merchandising Lookup Dimension information.

Table 4-2 RDE Fact Phases

FACT PHASE No. GROUPING FACTOR

P1

Consists of cost fact information jobs (for example, Base Cost, net Cost, and so on)

P2

Consists of price fact information jobs (for example, item price, competitor price, and so on)

P3

Consists of purchase order fact jobs

P4

Consists of transfer / RTV fact jobs

P5

Consists of Supplier fact jobs

P6

Consists of Stock Ledger fact jobs

P7

Consists of fact jobs related to inventory (for example, unavailable inventory, inventory receipt, and so on)

P8

Consists of fact jobs related to transactions - they mostly read from IF_TRAN_DATA (for example, deal income, intercompany margin, and so on)

P9

Consists of Allocation fact jobs

P10

Consists of stock count fact jobs

Ad Hoc Processes

There are several standalone ad hoc processes available for executing the RDE programs outside of a normal batch cycle. These processes can be used to integrate dimension or fact data to RAP during initial implementation, or simply to run the extracts and validate the outputs without actually loading them into the platform. The table below summarizes these processes and their usage.

Table 4-3 RDE Ad Hoc Processes

Process Name Usage

RDE_EXTRACT_DIM_INITIAL_ADHOC

Execute the dimension data extracts from RMFCS and write the result to RAP input staging tables directly. Data can then be moved into RAP if desired by using the LOAD_DIM_INITIAL_ADHOC process.

RDE_EXTRACT_CE_DIM_INITIAL_ADHOC

Execute the dimension data extracts from CE and write the result to RAP input staging tables directly. Data can then be moved into RAP if desired by using the LOAD_DIM_INITIAL_ADHOC process.

RDE_EXTRACT_FACT_INITIAL_ADHOC

Execute the fact data extracts from RMFCS and write the result to RAP input staging tables directly. This is mainly intended to allow a complete run of RDE fact jobs outside the normal batch process, loading the data into RI would require the use of numerous fact jobs and processes depending on the data needed.

RDE_POSITIONALFACT_SEED_ADHOC

Run all of the positional fact seed jobs needed to create full snapshots of positional data in RAP. After running these jobs, you may use the SEED_*_ADHOC processes to load each dataset (you must disable the COPY/STG steps of the seed processes before running them, because those steps will attempt to load from flat files instead of RMFCS).

RDE_INVPOS_SEED_ADHOC

Run the inventory position fact seed job needed to create full snapshots of inventory data in RI. After running these jobs, you may use the SEED_W_RTL_INV_IT_LC_DY_F_PROCESS_ADHOC process to load it (you must disable the COPY/STG steps of the seed processes before running them, because those steps will attempt to load from flat files instead of RMFCS).

RDE_INVRTVFACT_INITIAL_ADHOC

Extract RTV transaction history from RMFCS to RAP staging tables. Load the data into RAP using the HIST_CSV_INVRTV_LOAD_ADHOC process (you must disable the COPY/STG steps of the processes before running them, because those steps will attempt to load from flat files instead of RMFCS).

RDE_IVADJILDSDE_INITIAL_ADHOC

Extract adjustment transaction history from RMFCS to RAP staging tables. Load the data into RAP using the HIST_CSV_ADJUSTMENTS_LOAD_ADHOC process (you must disable the COPY/STG steps of the processes before running them, because those steps will attempt to load from flat files instead of RMFCS).

RDE_IVTSFILDSDE_INITIAL_ADHOC

Extract transfer transaction history from RMFCS to RAP staging tables. Load the data into RAP using the HIST_CSV_TRANSFER_LOAD_ADHOC process (you must disable the COPY/STG steps of the processes before running them, because those steps will attempt to load from flat files instead of RMFCS).

RDE_DEALINILDSDE_INITIAL_ADHOC

Extract deal income transaction history from RMFCS to RAP staging tables. Load the data into RAP using the HIST_CSV_DEAL_INCOME_LOAD_ADHOC process (you must disable the COPY/STG steps of the processes before running them, because those steps will attempt to load from flat files instead of RMFCS).

RDE_INVRECLASSSDE_HIST_ADHOC

Extract inventory reclass transaction history from RMFCS to RAP staging tables. Load the data into RAP using the HIST_CSV_INVRECLASS_LOAD_ADHOC process (you must disable the COPY/STG steps of the processes before running them, because those steps will attempt to load from flat files instead of RMFCS).

RDE_INTCMPMRGINSDE_HIST_ADHOC

Extract intercompany margin transaction history from RMFCS to RAP staging tables. Load the data into RAP using the HIST_CSV_ICMARGIN_LOAD_ADHOC process (you must disable the COPY/STG steps of the processes before running them, because those steps will attempt to load from flat files instead of RMFCS).

RDE_EXTRACT_SALES_ADHOC

Extract daily sales data from the Sales Audit staging tables to the RAP staging tables. This process is mainly intended to test the sales extracts outside the normal batch and to validate the data transformations, or use the RAP sales history load ad hoc processes to bring the sales into the platform.

RDE_TSFILDSDE_INITIAL_ADHOC

Extracts a full snapshot of data from RMFCS for the transfer details fact (W_RTL_TSF_IT_LC_DY_FS). Intended for data validation and history conversion. Meant to be loaded into RI using the nightly batch jobs.

RDE_SHIPDETAILSDE_INITIAL_ADHOC

Extracts a full snapshot of data from RMFCS for the shipment details dimension (W_RTL_SHIP_DETAILS_DS). Intended for data validation and history conversion. Meant to be loaded into RI using the nightly batch jobs.

RDE_SHIPILDSDE_INITIAL_ADHOC

Extracts a full snapshot of data from RMFCS for the shipment details fact (W_RTL_SHIP_IT_LC_DY_FS). Intended for data validation and history conversion. Meant to be loaded into RI using the nightly batch jobs.

RDE_ALLOCDETAILDYSDE_INITIAL_ADHOC

Extracts a full snapshot of data from RMFCS for the allocation dimension (W_RTL_ALC_DETAILS_DS). Intended for data validation and history conversion. Meant to be loaded into RI using the nightly batch jobs.

RDE_POONALCILDSDE_INITIAL_ADHOC

Extracts a full snapshot of data from RMFCS for the PO orders on allocation fact (W_RTL_PO_ONALC_IT_LC_DY_FS). Intended for data validation and history conversion. Meant to be loaded into RI using the nightly batch jobs.

RDE_REPLDAYSDE_INITIAL_ADHOC

Extracts a full snapshot of data from RMFCS for the Replenishment Days dimension (W_RTL_REPL_DAY_DS). Intended for data validation and history conversion. Meant to be loaded into RI using the nightly batch jobs.

RDE_REPLSUPDIMSDE_INITIAL_ADHOC

Extracts a full snapshot of data from RMFCS for the Replenishment Supplier Dims dimension (W_RTL_REPL_SUP_SIM_DS). Intended for data validation and history conversion. Meant to be loaded into RI using the nightly batch jobs.

Batch Setup for RMFCS (Gen 2 Architecture)

The way you configure the integration with RMFCS varies depending on where your Merchandising applications reside. In this scenario, you have both RMFCS and CE in our 2nd generation architecture and the version number is 22.1 or greater.

Take the following steps to configure the RDE portion of the batch schedule:

  • Disable the batch link between RI’s BATCH_INITIAL_START_PROCESS / GENERIC_BATCH_MILE_MARKER_JOB and RDE’s RDE_BATCHFINAL_PROCESS / RDE_BATCHFINAL_EXTLOAD_SUCCESS_JOB. This batch link should be disabled because RDE and RI are on the same POM and batch pod and a dependency is already in place for the RI job to start once the RDE jobs complete.

  • If the client opts not to integrate the ORCE customer data, the ORCE jobs can be disabled (those with RDE_EXTRACT_CE_*). These jobs are under the following modules:

    • RDE_CE

    • RDE_CE_BATCH

    • RDE_CE_REQUIRED

    • RDE_CE_OPTIONAL

    • RDE_CE_CUSTOMER

    • RDE_CE_CUSTSEG

    • RDE_CE_LOYALTY

  • If the client opts to integrate the ORCE customer data (which means that the ORCE jobs are enabled - those with RDE_EXTRACT_CE_*), the following RI jobs should be disabled as the customer data will directly be populated without an input file:

    • W_RTL_CUST_DEDUP_DS_COPY_JOB

    • W_RTL_CUST_DEDUP_DS_STG_JOB

    • W_RTL_CUST_LYL_AWD_TRX_DY_FS_COPY_JOB

    • W_RTL_CUST_LYL_AWD_TRX_DY_FS_STG_JOB

    • W_RTL_CUST_LYL_TRX_LC_DY_FS_STG_JOB

    • W_RTL_CUST_LYL_TRX_LC_DY_FS_COPY_JOB

    • W_RTL_CUST_LYL_ACCT_DS_COPY_JOB

    • W_RTL_CUST_LYL_PROG_DS_COPY_JOB

    • W_RTL_CUSTSEG_DS_COPY_JOB

    • W_RTL_CUSTSEG_DS_STG_JOB

    • W_RTL_CUSTSEG_DS_ORASE_JOB

    • W_RTL_CUST_CUSTSEG_DS_COPY_JOB

    • W_RTL_CUST_CUSTSEG_DS_STG_JOB

    • W_RTL_CUST_CUSTSEG_DS_ORASE_JOB

    • W_RTL_CUSTSEG_ATTR_DS_COPY_JOB

    • W_RTL_CUSTSEG_ATTR_DS_STG_JOB

    • W_RTL_CUST_HOUSEHOLD_DS_COPY_JOB

    • W_RTL_CUST_HOUSEHOLD_DS_STG_JOB

    • W_RTL_CUST_ADDRESS_DS_COPY_JOB

    • W_RTL_CUST_ADDRESS_DS_STG_JOB

    • W_PARTY_PER_DS_COPY_JOB

    • W_PARTY_PER_DS_STG_JOB

    • W_RTL_PARTY_PER_ATTR_DS_COPY_JOB

    • W_RTL_PARTY_PER_ATTR_DS_STG_JOB

    • W_HOUSEHOLD_DS_COPY_JOB

    • W_HOUSEHOLD_DS_STG_JOB

  • Disable most of the RI copy jobs (those with *_COPY_JOB) except ones needed for non-RMFCS sources. These jobs should be disabled because these jobs will copy files and upload them from object storage. This is not needed because data is loaded directly into the staging tables and flat files are not expected to arrive for processing. Most of these jobs are under the following modules:

    • RI_DAT_STAGE

    • RSP_DAT_STAGE

  • Disable most of the RI stage jobs (those with *_STG_JOB) ) except ones needed for non-RMFCS sources. These jobs should be disabled as these jobs read from a flat file which are not available if using this integration. Most of these jobs are under the following modules:

    • RI_DAT_STAGE

    • RSP_DAT_STAGE

  • Disable the RAP Simplified Interface jobs (those with SI_*) as RMFCS will be the source of data to feed RI. Most of these jobs are under the following modules with the pattern below:

    • RI_SI*

    • RSP_SI*

  • If you are not providing any flat file uploads and using only RMFCS data, you may disable the jobs in CONTROL_FILE_VALIDATION_PROCESS, which will prevent any data files from being processed (and potentially overwriting the RMFCS data).

Batch Setup for RMFCS (Gen 1 Architecture)

If your RMFCS version is in the Oracle cloud but the version number is 19.3 or earlier, then follow this process to configure the integration. In this case, RDE is a separate module installed in the RMFCS cloud, so the batch must be reconfigured accordingly to have the correct dependencies.

  1. Disable all the inter-schedule dependencies related to RDE in the RI schedule, as there is a separate batch schedule used for RDE that contains these:

  • CSTISLDSDE_PROCESS / CSTISLDSDE_JOB dependency with RMFCS ALLOCBT_PROCESS / ALLOCBT_JOB

  • CSTISLDSDE_PROCESS / CSTISLDSDE_JOB dependency with RMFCS BATCH_RFMCURRCONV_PROCESS / BATCH_RFMCURRCONV_JOB

  • CSTISLDSDE_PROCESS / CSTISLDSDE_JOB dependency with RMFCS COSTCOMPUPD_ELCEXPRG_PROCESS / ELCEXCPRG_JOB

  • CSTISLDSDE_PROCESS / CSTISLDSDE_JOB dependency with RMFCS EDIDLCON_PROCESS / EDIDLCON_JOB

  • CSTISLDSDE_PROCESS / CSTISLDSDE_JOB dependency with RMFCS EXPORT_STG_PURGE_PROCESS / EXPORT_STG_PURGE_JOB

  • CSTISLDSDE_PROCESS / CSTISLDSDE_JOB dependency with RMFCS EDIUPAVL_PROCESS / EDIUPAVL_JOB

  • CSTISLDSDE_PROCESS / CSTISLDSDE_JOB dependency with RMFCS LIKESTOREBATCH_PROCESS / LIKESTOREBATCH_JOB

  • CSTISLDSDE_PROCESS / CSTISLDSDE_JOB dependency with RMFCS POSCDNLD_PROCESS / POSCDNLD_POST_JOB

  • CSTISLDSDE_PROCESS / CSTISLDSDE_JOB dependency with RMFCS REPLINDBATCH_PROCESS / REPLINDBATCH_JOB

  • CSTISLDSDE_PROCESS / CSTISLDSDE_JOB dependency with RMFCS SALESPROCESS_PROCESS / SALESUPLOADARCH_JOB

  • CSTISLDSDE_PROCESS / CSTISLDSDE_JOB dependency with RMFCS STKVAR_PROCESS / STKVAR_JOB

  • RDEBATCH_INITIAL_START_PROCESS / RDEBATCH_INITIAL_START_MILEMARKER_JOB dependency with RMFCS STOP_RIB_ADAPTOR_INV_PROCESS / STOP_RIB_ADAPTOR_INV_JOB

  1. Disable the batch link related to RMFCS in the RI schedule:

    1. SETUP_PROCESS / REFRESHODIVARIABLES_JOB dependency with RMFCS STOP_RIB_ADAPTOR_INV_PROCESS / STOP_RIB_ADAPTOR_INV_JOB

  2. Disable all the ORCE jobs (those with RDE_EXTRACT_CE*). These jobs should not be executed because RDE is not in Gen 2 Architecture. The Customer Data jobs in RI should be enabled instead (for example, W_RTL_CUSTSEG_DS_COPY_JOB, W_RTL_CUSTSEG_DS_STG_JOB)

  3. Disable all the RDE jobs (those with RDE_EXTRACT_*). These jobs should not be executed as a separate RDE job schedule in POM will be setup for it. These jobs are under the RDE_RMS_* modules.

  4. Make sure that the RI copy jobs (those with *_COPY_JOB) are enabled. These jobs should be enabled as these jobs will copy files and upload them to the object storage which is the source of the files for RI processing.

  5. Make sure that the RI stage jobs (those with *_STG_JOB) are enabled. These jobs should be enabled as these jobs will read from flat files and load them into the RI staging tables.

  6. Disable the RI Simplified Interface jobs (those with SI_*) as RMS will be the source of data to feed RI. Most of these jobs are under the following modules with the pattern below:

    1. RI_SI*

    2. RSP_SI*

Batch Setup for RMS (On-Premise)

If your RMS application is installed on a local server outside the Oracle cloud, then you will need to integrate your local RDE installation with the RAP cloud following the guidance below. Additionally, you should also perform all the steps in the prior section to disable the RDE components of the RI POM schedule and enable the file load procedures, since you will be sending in files from RDE.

  1. Download the latest RDE version 22 patch from My Oracle Support, as the changes to support Object Storage upload are deployed by running the installer and upgrading your RDE environment.

  2. Disable FTP Configuration in RDE by setting the input.do.install.ftp to false in the ant.install.properties file. This must be disabled because File Transfer Services (FTS) for the Retail Analytics and Planning cloud services are made available in this release, replacing the current SFTP process

  3. Check that the FTS configuration file ra_objstore.cfg is available in RDE's $MMHOME/etc directory. The FTS configuration file contains the following variable set-up used for the Object Storage:

    • RA_FTS_OBJSTORE_IND – This will be set to Y so that FTS will be enabled

    • RA_FTS_OBJSTORE_URL – This is the Base URL

    • RA_FTS_OBJSTORE_ENVNAMESPACE – This is the Tenant

    • RA_FTS_OBJSTORE_IDCS_URL – This is the IDCS URL appended with /oauth2/v1/token at the end

    • RA_FTS_OBJSTORE_IDCS_CLIENTID – This is the Client ID

    • RA_FTS_OBJSTORE_IDCS_CLIENTSECRET – This is the Client ID Secret

    • RA_FTS_OBJSTORE_IDCS_SCOPE – This is the IDCS Scope

    • RI_OBJSTORE_UPLOAD_PREFIX – This is the Storage Prefix and is set to ris/incomingpointing to the correct Object Storage directory for RI input files

    Refer to the File Transfer Services section of this document for instructions on how to get the values for each of the variables above.

  4. Enable the File Transfer Service (FTS) in RDE by setting the RA_FTS_OBJSTORE_IND to Y in the FTS Configuration file ra_objstore.cfg found in RDE’s $MMHOME/etc directory. This must be enabled so that the RDE nightly zip file job (RTLRDEZIP_PROCESS / RTLRDEZIP_JOB) and all existing ad hoc zip file jobs (RTLUASDE_INITIAL_DIMMENSION_LOAD_ADHOC / RTLRDEZIP_HIST_JOB, RTLRDEZIP_HIST_PROCESS_ADHOC / RTLRDEZIP_HIST_JOB, INVRTVFACT_ADHOC / ADHOCINVRTVSDE_JOB, SEEDPOSITIONALFACT_ADHOC / SEEDRDEZIP_JOB) will automatically upload files to the Object Storage through FTS for RI to pick up and download for further processing.

  5. Once these changes are applied, it will no longer be possible to upload to SFTP; you will be sending the ZIP files only to Object Storage as specified in the install properties and configuration changes.

Using RDE for Initial Seeding (Gen 2 Architecture)

RDE nightly batch programs can be used to perform initial seeding and full snapshots of positional facts without running any ad hoc processes. This provides a way to seamlessly transition from history data loads to nightly batch loads. Follow the steps below to perform this transition:

  1. Navigate to the System Options in POM for the RDE/RI batch schedule.

  2. Update the variables RDE_RunFactVersion and RDE_RunFactODIVersion. By default, they should have a value of I as their rightmost input parameter, which is the normal incremental batch run. Change the value to F, which will trigger a full snapshot batch run. Do not change any other values already in these options except the letter I or F at the end.

  3. Schedule and run the full AIF nightly batch cycle and validate that all nightly data was processed as expected in your RAP solutions. If you want to validate the RDE extracts prior to running the rest of the nightly batches in RAP (for example, to confirm the full extracts worked as intended) you may place a Hold on one of the first RI jobs in the schedule, such as BATCH_START_NOTIFICATION_JOB.

Using RDE for Initial Seeding (Gen 1 Architecture)

RDE ad hoc batch programs in the RMFCS 19.x cloud can be used for initial seeding of RAP but the process is different from the 2nd generation architecture, as the integration is through flat files, not direct loads.

Integration from RDE (in Merchandising) to RAP occurs automatically as part of the RDE ZIP file upload jobs. RDE will push the ZIP file to the File Transfer Services location used by AI Foundation for incoming data (ris/incoming path in FTS). At this point, you have the option to run the AI Foundation batch jobs to use that ZIP or download it from FTS to manually modify it and re-upload it. Once the AI Foundation nightly batches are enabled, you would also enable the batch link connecting AIF to RDE, and then the entire end-to-end process will occur without user intervention.

For initial seeding, you would follow the process below:

  1. Set up a full RDE batch (by enabling batch links/dependencies to the RMFCS schedule) and let it run nightly to get the full set of RDE files for dimensions and facts.

  2. The file will be pushed automatically to RAP FTS. Download the RI_RMS_DATA.zip file from FTS; do not load it into RAP yet.

  3. Run the process SEEDPOSITIONALFACT_ADHOC, which will extract full snapshots of all positional data, zip them, and push them to the RAP FTS location.

  4. Download the RIHIST_RMS_DATA.zip file from FTS and copy the full snapshots of positional facts into the RI_RMS_DATA.zip file generated by the RDE nightly process (replacing the incremental files that were extracted).

  5. Upload the modified RDE nightly ZIP file to RAP FTS at the ris/incoming location (same as you would for all nightly batches going forward). Upload any additional ZIP files you need for the nightly batches, such as ORASE_WEEKLY.zip or RAP_DATA.zip, if you want these other files loaded in the same batch.

  6. Advance the ETL business date in AIF to one day before the current batch, if it’s not already set to that date, using the ad hoc process LOAD_CURRENT_BUSINESS_DATE_ADHOC. Review any configurations in C_ODI_PARAM and RSE_CONFIG tables which may have been altered for your historical loads but need updates for nightly batch data. For example, you may want to update RI_INVAGE_REQ_IND in C_ODI_PARAM if you need calculations of first/last receipt dates and inventory age from the RMFCS data.

  7. Schedule a run of the full AIF nightly batch. Ensure your AIF POM schedule dates for the nightly batch run is aligned with the completed run of RMFCS/RDE, because, from this point forward, the batch schedules will need to remain in sync.

Your transactional facts, such as sales and receipts, should already have history loaded up to this first run of nightly batches, because the next RDE nightly batch will only extract data for the current vdate in RMFCS (for example, it will use the contents of the IF_TRAN_DATA daily transaction table for most fact updates besides sales, which come from Sales Audit directly). Once this first AIF batch completes using the full snapshot of positional data, you may prepare for regular nightly batches which will use the incremental extracts from RDE.