| Oracle® Retail Advanced Inventory Planning Operations Guide Release 14.1.1 |
|
 Previous |
 Next |
Functionally the AIP batch scripts are broadly classified in Table 5-1. Each of the scripts listed next to its descriptive step name exists to perform that batch step.
Table 5-1 AIP Batch Scripts by Class
| AIP Batch Class | Step Description | Batch Script |
|---|---|---|
|
Set Implementation Parameters |
Set Implementation Parameters for DM and Replenishment |
set_implementation_parms.sh |
|
External Integration Data Processing |
Verify and Process Foundation Data from External System |
check_process_external_data.sh |
|
Create Empty Hierarchy files |
create_empty_default_files.sh |
|
|
Internal Integration Data Processing |
Prepare Data from AIP Online platform |
prep_from_aiponline.sh |
|
Process Merchandise System and AIP Online Hierarchies |
Merge Hierarchies |
merge_hierarchies.sh |
|
Convert Hierarchies for Loading |
convert_hierarchies_for_loading.sh |
|
|
Reconfigure AIP Domain Partitions |
reconfigAIPDomainPartitions.ksh |
|
|
Load Hierarchy and Non-Inventory Measure Data into AIP RPAS |
Load All Hierarchies |
load_all_hierarchies.sh |
|
Load AIP Online Measure Data |
load_online_measures.sh |
|
|
Load External Non-Inventory Measure Data |
load_rms_dm_measures.sh |
|
|
Generate and Load New Item Alert Measures |
Create Empty Archive File |
create_empty_archive_files.sh |
|
Generate Batch and Online Alerts |
load_all_newitem_alert_measures.sh |
|
|
Load External System Measure Data into AIP RPAS |
Load Non-RMS External Files |
load_non_rms_external.sh |
|
Commit Workbooks before Batch Run |
Auto Commit Workbooks |
workbook_batch.sh COMMIT |
|
Perform and Export Data Management Calculations |
Run Initial Load DM Batch |
run_partial_dm_batch.sh |
|
Run DM Batch |
dmb_master.sh |
|
|
Export DM Data |
export_dm_data.sh <true|false> |
|
|
Import schedules from AIP-O into AIP-R |
check_import_online_schedule.sh |
|
|
Run post schedule import DM batch |
dmb_master_post.sh |
|
|
External Integration Forecast Data Processing and Load into AIP RPAS |
Check and Load Forecast Data |
check_load_forecast_data.sh |
|
Prepare Replenishment Data and Maintain Histor |
Purge and Advance Low-Variability Data |
purge_low_variability_advance.sh |
|
Purge Truncate History |
for_each_local_domain.sh -p purge_truncate_history.sh.sh [DOMAIN] |
|
|
Copy Sister Stores and Warehouses |
for_each_local_domain.sh -p copy_sister_data_local.sh [DOMAIN] |
|
|
External Integration Inventory Data Processing and Load into AIP RPAS |
Verify and Process Inventory Data from External System |
check_process_inventory_data.sh |
|
Load Replenishment Inventory Data |
load_replenishment_measures.sh |
|
|
Calculate and Export Replenishment Plan |
Run Replenishment |
scrp.sh |
|
Export Supply Chain Replenishment Data |
for_each_local_domain.sh -p export_scrp_inter_meas_local.sh [DOMAIN] |
|
|
Package Supply Chain Replenishment Data |
send_scrp_measures_to_online.sh |
|
|
Import Cross Dock Constraint Receipt Plan (DCRP) output into AIP-R |
Import DCRP output into AIP-R domain |
post_dcrp_import.sh |
|
Load the Scaled Replenishment Plan |
Run Post Supplier and Container Scaling Import |
post_ocs_import.sh |
|
Perform Post-Replenishment Calculations |
Run Replenishment Post-processing |
for_each_local_domain.sh -p scrp_post_local.sh [DOMAIN] |
|
Calculate and Export Data Management Alert |
Run Non-critical Data Management Alerts |
dmb_master_alerts.sh <true|false> |
|
Export DM Alerts |
export_dm_alerts.sh <true|false> |
|
|
Compute Replenishment Alerts |
Run SRP Item Alerts |
scrp_srp_alerts.sh |
|
Run WRP Item Alerts |
wrp_item_alerts.sh |
|
|
Run WRP Network Alerts |
wrp_network_alerts.sh |
|
|
Run Replenishment Alerts Post Processing |
replenishment_alerts_post_processing.sh |
|
|
Build Workbooks after Batch Run |
Auto Build Workbooks |
workbook_batch.sh BUILD |
|
Run Calculations for OBIEE Reports |
Calculate Data for OBIEE Reports |
run_OBIEE_reports.sh |
|
Calculate Dashboard Measures |
Calculate AIP Dashboard data |
run_dashboard.sh |
Step Name
set _implementation_parameters
Script Call
set_implementation_parms.sh
Functional Overview
This script is called to set configurable parameters for DM and replenishment. All parameters are set in measure data and are initialized by running mace expressions using values defined in the shell script aip_env_rpas.sh.
Technical Details
The script set_implementation_parms.sh calls the scripts set_implementation_parms_dm.sh and set_implementation_parms_aip.sh. Each of the scripts is a simple list of rules to be executed as mace commands on the global $AIPDOMAIN. The values of the measures are taken from the configurable shell script aip_env_rpas.sh.
Day on Day Processing
This script performs these steps for day on day processing:
Call set_implementation_parms_aip.sh to execute its list of expressions through mace.
Call set_implementation_parms_dm.sh to execute its list of expressions through mace.
This Script Calls these Scripts:
set_implementation_parms_dm.sh
set_implementation_parms_aip.sh
Appropriate Batch Run (First Time, Daily, or Both)
First Time or ad hoc if a desired value changes.
Prerequisites
Values for all implementation parameters listed in aip_env_rpas.sh must be edited to meet the business requirements of the client.
Restart/Recovery
If this script fails, perform the following steps:
Examine the log files to determine the cause of the failure.
Correct any identified setup or environment issues.
Restart the batch.
To begin, the data must be exported from RMS or another external system. AIP is integrated with an external system by means of this series of scripts and refers to this series of scripts as Integration. The export of this data is not part of the AIP data export scripts; however, AIP is dependent on the data being available before AIP can proceed with data population. The foundation and inventory data from RMS or another external system are loaded into RPAS as part of the AIP data load process.
Step Name
check_process_external_data
Script Call
check_process_external_data.sh
Optional Parameters
-h: to display script usage
Functional Overview
RMS is an enterprise solution that provides merchandise hierarchy and organizational setup and maintenance. This data, together with non-RMS external system data, becomes the foundation for the AIP supply chain replenishment. The data is processed as a set of flat files that follow an agreed AIP file format. If the client does not use RMS, but rather some other external system, this data is still required in the same format. AIP validates all of the files to ensure that the required data is present, and massages the files to produce the input required for subsequent steps of the AIP RPAS batch. AIP divides the integration data into two categories: early files and late files. The batch schedule for AIP may aim to maximize the available time by moving as much workload off the critical path as possible. For this reason the static data is extracted from RMS, or similar system, before the dynamic transaction data is available. This allows the hierarchies to be loaded into AIP and the DM batch run before the dynamic data is extracted. This step processes the early, static data.
Technical Details
The static hierarchy and measure data are listed in Table 5-2, Table 5-3, and Table 5-4. For AIP RPAS batch to properly process external system data, all of the flat files must follow a particular format. The flat files should have a *.txt extension.
Table 5-2 lists files that are verified and processed inside the check_process_external_data.sh script, which if the client has RMS and has installed the RMS-AIP Transformation Scripts, are outputs from that transformation process. If the client does not have RMS, then these files are still required. These data are loaded into the RPAS domain as either hierarchy or measure data.
Table 5-2 Early Dynamic and Reference Data
| File Name | Explanation |
|---|---|
|
item.txt |
Product Hierarchy |
|
loc.txt |
Location Hierarchy |
|
splr.txt |
Supplier Hierarchy |
|
whse.txt |
Warehouse Hierarchy |
|
dm0_pmsendsrc.txt |
Store Promotional Substitution End Date for Warehouses |
|
dm0_pmsstasrc.txt |
Store Promotional Substitution Start Date for Warehouses |
|
dmx_bndprdasc.txt |
Banded Commodity Association |
|
dmx_dirspl.txt |
Direct Suppliers |
|
dmx_dscdt_.txt |
Corporate Discontinuation Date |
|
dmx_prdspllks.txt |
Commodity-Supplier Links |
|
dmx_vadprdasc.txt |
Value Added Commodity Association |
Table 5-3 lists additional files processed by the check_process_external_data.sh script. However, these are not possible outputs from the RMS-AIP Transformation. These data are also loaded into the RPAS domain as either hierarchy or measure data.
Table 5-3 Load-Ready External Systems Data
| File Name | Explanation |
|---|---|
|
had.txt |
Advertising Hierarchy |
|
intv.txt |
Interval Hierarchy |
|
dm0_ofseffdt_.txt |
Off-Sale Effective Date |
|
dm0_onseffdt_.txt |
On-Sale Effective Date |
|
dmx_pprsts.txt |
Pre-Priced Status |
|
dmx_shpto_.txt |
Receiving Supplier / Ship To |
|
ipavgrtslsi.txt |
Total Store Average Rate Of Sales |
|
iphldbckqtyi.txt |
Hold Back Quantity |
|
ipiavgrtslsi.txt |
WH Independent ARS |
|
ipldssi.txt |
Loaded Safety Stock |
|
ipodcmti.txt |
Order Commit |
|
iprpltcdi.txt |
Replenishment Type Code |
|
iprplstcdi.txt |
Replenishment Subtype Code |
|
ipslsi.txt |
Historical Weekly Sales |
|
sr0_ad_.txt |
Store Ads |
|
sr0_ad_go_.txt |
Store Ads Grand Opening |
|
sr0_ad_irt.txt |
Store Ads Inserts |
|
sr0_ad_oth.txt |
Store Ads Others |
|
sr0_ad_rop.txt |
Store Ads Run on Press |
|
sr0_adjsls.txt |
Store Adjusted Sales |
|
sr0_avgrosld_.txt |
Store Average Weekly Rate of Sale Loaded |
|
sr0_co_.txt |
Store Customer Orders |
|
sr0_expwrtoff.txt |
Store Expected Write-off |
|
sr0_hstls_.txt |
Store Historical Lost Sales |
|
sr0_knowndemand.txt |
Store Known Demand |
|
sr0_ovrstkflg.txt |
Run Overstock Alert Flag |
|
sr0_rplcde.txt |
Store Repl Type Code |
|
sr0_rplsubcde.txt |
Store Repl Subtype Code |
|
sr0_ss_ld_.txt |
Store Loaded Safety Stock |
|
sr0_tdgday.txt |
Store Trading Days |
|
srx_prdrpr.txt |
SKU Retail Price |
|
ipfctwkprfd.txt |
Week to Day Forecast Percentage Default (Un-Normalized) |
|
ipfctwkprfe.txt |
Store Week to Day Forecast Percentage Override (Un-Normalized) |
|
ipwhhldcpci.txt |
Stocking Point Holding Capacity |
|
srx_poidst.txt |
Poisson Distribution Lookup Table |
|
sr0_wkbsf_ld.txt |
Loaded Weekly Base Sales Forecast |
|
ipttlhlstki.txt |
Total Held Stock |
|
ipadstai.txt |
Store Ad Start Date |
|
ipadendi.txt |
Store Ad End Date |
|
sr0_dyscsls.txt |
Daily Short Code Sales |
|
sr0_invadj.txt |
Inventory Adjustments |
|
sr0_wstadj.txt |
Waste Adjustments |
|
ipibcpcco.txt |
Inbound Capacity Cases for Reporting |
|
ipobcpcco.txt |
Outbound Capacity Cases for Reporting |
Table 5-4 lists non-load-ready data that is received from an external (non-RMS) system, which is processed by the check_process_external_data.sh script. This data is prepared for intragration transfer to AIP Online, but some of the data is split to create load-ready measure data that is loaded into the RPAS domain.
Table 5-4 Non-Load-Ready External Systems Data
| File Name | Explanation |
|---|---|
|
default_wh.txt |
Default Warehouse. This data file is split into two load-ready data files:
|
|
direct_store_format_pack_size.txt |
Direct Store Format Pack Size |
|
direct_store_pack_size.txt |
Direct Store Pack Size |
|
store_format_pack_size.txt |
Store Format Pack Size |
|
store_pack_size.txt |
Store Pack Size |
|
item_attribute.txt |
Item Attribute |
|
item_attribute_type.txt |
Item Attribute Type |
|
sister_store.txt |
Sister Store Information. This data file is split into two load-ready data files:
|
|
sister_wh.txt |
Sister Warehouse. This data file is split into two load-ready data files:
|
|
wh_type.txt |
Warehouse Type |
Day on Day Processing
This script performs these steps for day on day processing:
Verify that all required files have been downloaded. Failure to download any of the required files results in an error and termination of the batch.
Split the sister_store.txt, sister_wh.txt and default_wh.txt files into load-ready data files as described in the previous tables.
Prefix the following measure data with the stocking point prefixes, using construct_ntier_measuredata.ksh:
dm0_pmsstasrc.txt
dm0_pmsendsrc.txt
dmx_prdspllks.txt
dmx_dirspl.txt
wh_type.txt
Using interutil binary, $AIPDOMAIN/interface/config/rms/hier/item.config, and the $AIPDOMAIN/interface/config/rms/hier/prod_external.format file, the following hierarchy and measure files are created from item.txt.
| File Name | Label |
|---|---|
| prod.dat | RMS Product Hierarchy |
| dmx_rmsskumap.ovr | RMS SKU Map |
| dmx_pszmap.ovr | Pack size Map |
In addition, the interutil program converts from RMS SKU to AIP SKU all RMS-sourced inventory measure data that has been configured to arrive early, and therefore is present to be processed by this script (as opposed to arriving late, and therefore is processed by check_process_inventory_data.sh).
|
Note: The dmx_rmsskumap measure data is not loaded into RPAS. The later mapping of RMS SKU to AIP SKU is done without use of this loaded data. However, this data is still required as it is delivered to the AIP Oracle part of the application. |
Rename prod.dat to prod.txt.
Call construct_ntier_hierarchies.sh to add stocking point prefixes to whse.txt, loc.txt, splr.txt, and generate the ssp and dsp hierarchy.dat files.
Copy prod.txt and whse.txt from $AIPDOMAIN/interface/rms/input to prod.def and whse.def in $AIPDOMAIN/interface/import for merging in a later step with AIP-Oracle DB product and warehouse contributions. Also copy splr.txt and loc.txt in $AIPDOMAIN/interface/rms/input to hspl.dat and loc.dat in $AIPDOMAIN/interface/import/hier.
Move non-RMS, external, measure data listed in $AIPDOMAIN/interface/config/external/measdata_from_external.config from the $AIPDOMAIN/interface/rms/input directory to the $AIPDOMAIN/interface/external directory where they are loaded into the AIP domain through a later script, load_non_rms_files.sh.
Move non-RMS, external, non-measure data listed in $AIPDOMAIN/interface/config/external/aiponlinedata_from_external.config to $AIPDOMAIN/interface/export so it can be exported to AIP online through a later script. During this step, prior to moving wh_type.txt, make a copy of wh_type.txt as $AIPDOMAIN/interface/external/dmx_wh_typ.ovr so it can be loaded into the $AIPDOMAIN.
Create a copy of hspl.txt named prof.def. In a later step, when Automatic Warehouse Profile Creation is enabled, this file is formatted to match the warehouse profiles created for Suppliers and merged with the existing DM Online Warehouse Profiles.
Remove the marker $AIPDOMAIN/interface/export_dm_data, set by send_dm_measures_to_online.sh. This marker indicates a successful export in the export_dm_data.sh call from the previous run of AIP RPAS batch. When marker is not present, the export process exports deltas, and sets the marker. If the marker is present, then export_dm_data.sh preserves a backup of the previous export before generating a new one, in order that a restart/recovery of this step can be implemented.
This Script Calls these Scripts:
_check_for_required_files (a function defined in bsa_check_for_required_files.sh)
process_external_data.sh
Appropriate Batch Run (First Time, Daily, or Both)
First Time and Daily.
Prerequisites
This step must not be initiated until the following is successfully completed:
Before this script runs, all data files from Table 1, Table 2, and Table 3 should be copied by the client's batch scheduler into the $AIPDOMAIN/interface/rms/input directory. Some of the data is required, and some is optional. Reference the $AIPDOMAIN/interface/config/external/earlyfiles.config for requirements.
Restart/Recovery
If this script fails, perform the following steps:
Examine the log files to determine the cause of the failure.
Correct any identified setup or environment issues.
Move prod.txt, whse.txt, splr.txt, and loc.txt to the $AIPDOMAIN/interface/import directory. The purpose of this is to have hierarchies ready in AIP Online format, and they should be merged with the actual AIP Online hierarchies at a later step.
Re-copy or re-FTP all required merchandising and external system*.txt files into the $AIPDOMAIN/interface/rms/input directory.
Restart the batch.
|
Note: This step can be run in parallel with Export DM and OM Online Data and Retrieve data from AIP Online. |
Step Name
create_empty_default_files
Script Call
create_empty_default_files.sh
Functional Overview
When AIP Batch is run for the first time, there is no AIP Online data that can be imported into AIP RPAS. Therefore there are no product and warehouse hierarchy files provided by AIP Online to be merged with the product and warehouse hierarchy files provided by an inventory management system. This step creates empty files that act as placeholders for the merge operation.
Technical Details
The script create_default_positions.sh is used to create 0-byte files for prod.dat and whse.dat.
Day on Day Processing
This script performs these steps for day on day processing:
Remove $AIPDOMAIN/interface/import/*.dat. This clears out any unwanted, residual data that exist prior to the first-time run.
Use UNIX touch command to create $AIPDOMAIN/interface/import/prod.dat and $AIPDOMAIN/interface/import/whse.dat.
Appropriate Batch Run (First Time, Daily, or Both)
First Time only.
Prerequisites
None.
Restart/Recovery
If create_empty_default_files.sh fails, perform the following steps:
Examine the log files to determine the cause of the failure.
Correct any identified setup or environment issues.
Restart the batch.
AIP RPAS is integrated with AIP Online by means of exporting data from AIP Online into AIP RPAS, and at the end of the AIP RPAS batch process, by exporting data from AIP RPAS into AIP Online. These two exchanges inside AIP are referred to as Intragration. The first export occurs early in AIP RPAS batch to retrieve the AIP Online data into the AIP RPAS domain.
Step Name
prep_onl_data
Script Call
prep_from_aiponline.sh
Functional Overview
You setup and maintain the supply chain and many replenishment parameters in DM Online. All of this data is used by AIP RPAS batch. For AIP RPAS batch to use this data, it must be retrieved from the Oracle database and loaded into the RPAS domain.
In addition to supply chain data, DM Oracle batch maintains the virtual date used by AIP RPAS batch. This value is loaded into RPAS along with the rest of the DM Online data.
Technical Details
AIP RPAS processes data from AIP Online. AIP Online exports hierarchy information and DM measures which are placed by the user into the AIP RPAS domain, in the $AIPDOMAIN/interface/import directory.
The prep_from_aiponline.sh script is called to process the data files created by the AIP Online export. The data files should be transferred from AIP Online to the export directory by a job scheduling application.
Day on Day Processing
This script performs these steps for day on day processing:
prep_files.sh is called two times. The first call processes the AIP Online hierarchy export. The second call processes the AIP Online measure export. The
prep_files.sh script is invoked with two keys that are listed inside $AIPDOMAIN/interface/config/bsa_prep_files.config:
DMo_hier_export is keyed to process the file hierarchy.tar.Z and unpack the data contained within to the $AIPDOMAIN/interface/import/hier directory.
DMo_meas_export is keyed to process the file aip.tar.Z and unpack the data contained within to the $AIPDOMAIN/interface/import/meas directory.
The data unpacked overwrites any existing files in these two directories.
Before each archive is unpacked, a backup of the file is created in the
$BSA_ARCHIVE_DIR directory. The backup filenames are aip.tar.Z.<timestamp> and hierarchy.tar.Z.<timestamp>.
After each archive is unpacked, the archive file is removed from $AIPDOMAIN/interface/import.
Verify existence of the unpacked measure data files using the compressed.config, uncompressed.config and lowvariability.config file lists in $AIPDOMAIN/interface/config/meas. If any are missing, halt batch with error.
Two data files are moved from $AIPDOMAIN/interface/import/hier to $AIPDOMAIN/interface/import: prod.dat and whse.dat. This is to prepare for the hierarchy merging.
Boolean TRUE values are appended to the data that is currently exported from AIP Online. The files are overwritten in the $AIPDOMAIN/interface/import/meas directory. Files currently exported in this way that have Boolean TRUE values appended are currently the following files:
dm1_prflks
This script calls the following script:
prep_files.sh
Appropriate Batch Run (First Time, Daily, or Both)
Daily only.
Prerequisites
This step must not be initiated until successful completion of the following:
The cron_export.sh script runs in the AIP Oracle schema.
Restart/Recovery
If this step fails, perform the following steps:
Examine the log files to determine the cause of the failure.
Correct any identified setup or environment issues.
Ensure that cron_export.sh ran correctly on the AIP Oracle schema. If it did not, perform the restart/recovery steps for cron_export.sh.
Ensure that *.Z files were correctly FTPed to RPAS. If not, archive or remove any RPAS zip files under $AIPDOMAIN/interface/import and rerun the client-owned batch process to FTP the data from AIP Oracle side to AIP RPAS side.
|
Note: Both the hierarchy.tar.Z and aip.tar.Z files need to exist in the [domain]/interface/rms directory. |
If cron_export.sh ran correctly, but the prep_from_aiponline.sh fails because of a measure data file or hierachy data file, then determine which data file caused the failure.
If the measure data file failed, then run: prep_from_aiponline.sh -meas
If the hierachy data file failed, then run: prep_from_aiponline.sh -hier
Restart the batch.
|
Note: This step can be run in parallel with check_process_external_data. |
Before AIP RPAS can manipulate the measure data, first the new hierarchy data must be loaded. New hierarchy positions can potentially arrive from both the merchandising system (such as RMS) as well as from AIP Online.
Step Name
merge_hierarchies
Script Call
merge_hierarchies.sh
Functional Overview
After the initial run, AIP RPAS batch loads data from RMS and AIP Online. Various AIP specific attributes of the RMS foundation data are maintained in DM Online. These attributes must be merged with the data that was loaded from RMS before being loaded into the RPAS domains.
|
Note: AIP Online does not allow the modification of any attributes mastered in RMS, such as warehouse name, SKU name, or department. |
Technical Details
This step merges the AIP Online hierarchies with the external system hierarchies (RMS). At a later time, the merged hierarchies are loaded into the AIP RPAS. The merge_hierarchies.sh script is used to perform the merge.
Day on Day Processing
This script performs these steps for day on day processing:
The prod.dat and whse.dat files have default positions, which are later assigned through AIP Online. Therefore, these files need to be merged with the RMS hierarchies. AIP Online does not affect the location and supplier hierarchy files. Therefore, the RMS contributions of loc.txt and hspl.txt are moved to be loaded directly into AIP RPAS domains.
The hierarchies are merged using run_interutil.sh. The run_interutil.sh uses the interutil binary and hierarchy configuration files to merge the online hierarchy with the RMS hierarchy and to generate the final hierarchy file.
prod.dat + prod.def using prod.config generates prod.dat
whse.dat + whse.def using whse.config generates whse.dat
All of these outputs are in AIP Online format and need to be converted to AIP RPAS format before getting loaded into RPAS.
Call merge_prof.sh to merge prof.def from External Source and prof.dat from AIP Online.
Remove pre-merge files from $AIPDOMAIN/interface/import: prod.def, prod.dat, whse.def, whse.dat.
This Script Calls these Scripts:
run_interutil.sh
merge_prof.sh
Prerequisites
All steps documented previously in this guide.
Restart/Recovery
If this step fails, perform the following:
Examine the log files to determine the cause of the failure.
Correct any identified setup or environment issues.
Ensure that the RMS data files (prod.def and whse.def) exist in the $AIPDOMAIN/interface/import directory with the correct format.
If they do not exist, re-copy $AIPDOMAIN/interface/rms/prod.txt to $AIPDOMAIN/interface/import/prod.def, and $AIPDOMAIN/interface/rms/whse.txt to $AIPDOMAIN/interface/import/whse.def.
Ensure that the AIP Online files (prod.dat and whse.dat) exist in the $AIPDOMAIN/interface/import directory with the correct format.
If they do not exist, extract prod.dat and whse.dat from $BSA_ARCHIVE_DIR/hierarchy.tar.Z.<timestamp> and place them in $AIPDOMAIN/interface/import.
Restart the batch.
Step Name
convert_hierarchies_for_loading
Script Call
convert_hierarchies_for_loading.sh
Functional Overview
This script preprocesses a subset of the hierarchy load files, prepending position names to the existing label field text.
Technical Details
The following hierarchy load files are preprocessed to prepend the hierarchy position names to the position labels:
prod
loc
whse
hspl
ssp
dsp
The prepending process is handled in a set of awk scripts.
The converted hierarchy data files and all other hierarchy files are copied to the $AIPDOMAIN/input directory.
Day on Day Processing
This script performs these steps for day on day processing:
Remove any existing hierarchy load files, $AIPDOMAIN/input/*.dat.
Copy from $AIPDOMAIN/interface/import/hier to $AIPDOMAIN/input all files (matching the pattern *.dat). This copies the following files:
Location and Supplier hierarchy data files received from merchandising system.
Network Group, Order Lead Time Cycle, Order Group, and Profile Order Cycle hierarchy data received from AIP-Oracle.
Product, Warehouse and Profile hierarchy data files merged from merchandising system and AIP-Oracle.
Move the Advertising and Interval hierarchy data files (if they exist), and the Source and Destination Stocking Point hierarchy data files from $AIPDOMAIN/interface/rms to $AIPDOMAIN/input.
Copy the calendar (clnd.dat or clnd.csv.dat, whichever is in $AIPDOMAIN/interface/rms) into $AIPDOMAIN/input.
Merge the position name into the label for the product, location, warehouse, supplier, source and destination stocking point hierarchies, so that when viewed through the RPAS Client, the position name is displayed in the label.
Copy the product, location, supplier and warehouse hierarchy files from $AIPDOMAIN/input to $AIPDOMAIN/interface for processing by the new hierarchy alert logic later in the AIP RPAS batch.
This Script Calls these Scripts:
convert_hierarchies_to_csv_for_load.sh
mergeProdPositions.awk
mergeStrPositions.awk
mergeWhPositions.awk
mergeSplrPositions.awk
mergeDspSspPositions.awk
Appropriate Batch Run (First Time, Daily, or Both)
First Time
Daily
Prerequisites
This step must not be initiated until successful completion of the following:
merge_hierarchies.sh
Restart/Recovery
If this step fails, perform the following:
Examine the log files to determine the cause of the failure.
Correct any identified setup or environment issues.
Restart the batch.
Step Name
reconfig_domain_partitions
Script Call
reconfigAIPDomainPartitions.ksh
Functional Overview
This step automates the addition of new partitioning dimension positions to the AIP RPAS domain. When adding these subclasses, it ensures that no local domain is overloaded and spreads the incoming subclasses as evenly as possible. It also ensures that related items, in term of merchandise hierarchy, are clustered together in local domains.
Technical Details
This script is a wrapper script to the script generateReconfigPartDimXml.ksh and the RPAS_HOME/bin utility reconfigGlobalDomainPartitions to be used within AIP. The script generateReconfigPartDimXml.ksh creates reconfigpartdim.xml if any new subclass is coming from RMS in the prod.dat file.
The xml file reconfigpartdim.xml may be created during this process. This file is created if a new subclass is found in the prod.dat which is not part of the existing domain structure. The RPAS utility reconfigGlobalDomainPartitions use the auto-created reconfigpartdim.xml to add the new subclass positions to the domain.
In a first day run, the call to generateReconfigPartDimXml.ksh is bypassed. It is assumed that on the first day, the subclasses loaded into the domain during domain creation are in synchronization with the subclasses in the product hierarchy loaded from merchandising system and therefore there are no new subclasses.
In an every-day run, if logic in this step determines that all subclasses are new, then generateReconfigPartDimXml.ksh will not generate reconfigpartdim.xml file and no reconfiguration will be run. All new subclasses will be placed in the default domain (as specified by $DEFAULT_DOMAIN variable in $RPAS_HOME/bin/aip_env_rpas.sh) during the load_all_hierarchies step of aip_batch.sh.
To remove positions along the partitioning dimension, use the AIP RPAS Purging functionality described in the AIP Interval Batch Scripts chapter of this guide.
Day on Day Processing
This script performs these steps for day on day processing:
Call generateReconfigPartDimXml.ksh to search $AIPDOMAIN/input/prod.dat, looking for new partitioning dimension positions. If any is found, generate $AIPDOMAIN/config/reconfigpartdim.xml.
If both of the following files exist:
$AIPDOMAIN/config/reconfigpartdim.xml
$AIPDOMAIN/input/prod.dat
Then run dimension addition by:
Calling reconfigGlobalDomainPartitions to add the positions indicated in reconfigpartdim.xml.
Move reconfigpartdim.xml to the $AIPDOMAIN/input/processed directory and append a timestamp to the file.
Appropriate Batch Run (First Time, Daily, or Both)
First Time
Daily
Prerequisites
This step must not be initiated until successful completion of the following:
convert_hierarchies_for_loading.sh
Restart/Recovery
If this step fails, perform the following:
Examine the log files to determine the cause of the failure.
Correct any identified setup or environment issues.
Restart the batch.
The following sections describe the process of Load Hierarchy and Non-Inventory Measure Data into AIP RPAS.
Step Name
load_all_hierarchies
Script Call
load_all_hierarchies.sh
Functional Overview
This script loads all hierarchy load files into the global and local domains.
Technical Details
All hierarchy load files are loaded into AIPDOMAIN and its local domains by standard RPAS functionality.
Day on Day Processing
Call loadHier to load all hierarchy load files found in the $AIPDOMAIN/input directory.
Appropriate Batch Run (First Time, Daily, or Both)
First Time
Daily
Prerequisites
This step must not be initiated until successful completion of the following:
reconfigAIPDomainPartitions.ksh
Restart/Recovery
If this step fails, perform the following:
Examine the log files to determine the cause of the failure.
Correct any identified setup or environment issues.
If the script failed to load specific positions, identify from where these positions are coming.
If new positions are coming from RMS, identify them in item.txt. If the data coming from RMS is incomplete, remove that line and raise a defect to the RMS team.
If new positions are coming from DM Online with erroneous data or bad formatting, remove data from the load file and raise a defect for DM Online.
If there are no new positions coming from either system, recopy from $AIPDOMAIN/input/processed to $AIPDOMAIN/input the previous successful hierarchy loads. Remove the timestamp suffix so that the suffix is .dat.
Restart the batch.
|
Note: If the files are in the correct format, you should be able to run the loadHier RPAS utility on individual files without rerunning the entire step.
|
Step Name
load_onl_data
Script Call
load_online_measures.sh
Functional Overview
Data files from the AIP Online part of AIP are loaded into the AIP RPAS domain.
Technical Details
The data files from AIP Online are listed in two configuration files: $AIPDOMAIN/interface/config/meas contains compressed.config and uncompressed.config. The compressed.config file lists the measure data files that are compressed by time, in that consecutive (by day) equivalent values are not contained in the data for the same intersection (example, SKU/store). The uncompressed.config lists the measure data files that are not compressed by time.
Each measure listed in these two configuration files is contained in the aip.tar.Z file which is transferred from the AIP Online server to the AIP RPAS server, and unpacked in the $AIPDOMAIN/interface/import/meas directory, in the previously described process.
The compressed measure data follows this technical process: the data is loaded into a compressed staging measure, then uncompressed into the actual measure array. The measure data is uncompressed to a different target end date depending on the planning horizon and other functional considerations. The uncompressed measure data is loaded into the measure array without need for staging measure load and uncompressing. In both cases, the measure data is always loaded as an overlay (a load into currently populated data locations overwrites, and all other data remains intact); however, the measure array may be partially or a fully cleared prior to this overlay load, depending on the functional requirements. Neither the compression/uncompression flag, nor the end date for uncompressing, nor the clearing prior to load are configurable by the client.
Day on Day Processing
This script performs these steps for day on day processing:
All measure data files listed in the uncompressed.config, compressed.config, and lowvariability.config are moved from $AIPOMAIN/interface/import/meas/*.dat to $AIPOMAIN/input/*.ovr.
The measure data deletion flags, which indicate values have been deleted in AIP Online, are converted into actual NA values.
The planning horizon measures are loaded.
All measure data files listed in the uncompressed.config and lowvariability.config are cleared (if scheduled for clear operation) and loaded into the measure arrays in $AIPDOMAIN.
All measure data files listed in the compressed.config are cleared (if scheduled for clear operation) and uncompressed into the measure arrays in $AIPDOMAIN.
All measures with a day dimension in their base intersection, but which are not scheduled for future-clear operation, are extended by one day to accommodate the rollover of the actual day.
This script or sub-scripts call the following programs:
clearArray (AIP binary)
compressValues (AIP binary)
loadmeasure (RPAS binary)
load_measures.sh
run_interutil.sh (script wrapper for interutil AIP binary)
xmace (AIP script wrapper for RPAS mace binary)
Appropriate Batch Run (First Time, Daily, or Both)
Daily.
Prerequisites
This step must not be initiated until successful completion of the following:
All prior steps in this AIP batch process must be completed with the exception of check_process_inventory_data. The data load is dependent on the successful loading of the new hierarchy information from AIP Online merged with External Hierarchy data.
Restart/Recovery
If this step failed, check the following:
Examine the log generated to understand why it failed.
If the failure was for a specific measures, check which positions within that measures is failing.
Ensure that those positions were successfully loaded during the Load All Hierarchies step.
If all positions are correctly loaded, check to ensure that the data formats in the *.dat files from Online are correct.
If positions were incorrectly loaded during the Load All Hierarchies step, fix it, and re-run loadHier with the correct values for the domain where the failure occurred.
Extract the most recent $BSA_ARCHIVE_DIR/aip.tar.Z.<timestamp> into $AIPDOMAIN/interface/import/meas directory.
Special processing is required to make dm1_prflks loadable:
Rename $AIPDOMAIN/interface/import/meas/dm1_prflks.dat to tmp_dm1_prflks.dat.
Run the following command:
sed -e 's/$/1/g' $AIPDOMAIN/interface/import/meas/tmp_dm1_prflks.dat > $AIPDOMAIN/interface/import/meas/dm1_prflks.dat
Remove $AIPDOMAIN/interface/import/meas/tmp_dm1_prflks.dat
Restart the batch.
Step Name
load_rms_dm_data
Script Call
load_rms_dm_measures.sh
Functional Overview
This step preprocesses and loads into the RPAS domain all Data Management measure data that comes from RMS or another external inventory system.
Technical Details
This script loads into $AIPDOMAIN all Data Management measure data in $AIPDOMAIN/interface/rms.
Day on Day Processing
This script performs these steps for day on day processing:
Call loadmeasure on the measure data files corresponding to the Data Management measure data received from the inventory system (example, RMS). The measures loaded are listed in the following configuration files:
$AIPDOMAIN/interface/config/rms/meas/rms_sku_map.config
$AIPDOMAIN/interface/config/rms/meas/dm_rms_measures.config
|
Note: Some measures are loaded as overlays (.ovr) and some are loaded as full replacement (.rpl). This is not intended to be configurable due to functional requirements. |
Before loading Promotional Start and End Date for Warehouses measures, filter out any rows of data in the dm0_pmsstasrc.txt and dm0_pmsendsrc.txt files which are already populated in the AIP domain's measure arrays in order to retain the measures' existing values.
This script calls the following programs:
loadmeasure
exportData
Appropriate Batch Run (First Time, Daily, or Both)
First Time
Daily
Prerequisites
This step is dependent on successful completion of the following:
All steps through the load_all_hierarchies.sh script
Restart/Recovery
If this step fails, you need to check the following:
Ensure all DM RMS files listed in the two configuration files are present in $AIPDOMAIN/interface/rms.
For those that loaded successfully according to the log files, there is no need to copy them back to $AIPDOMAIN/interface/rms.
For those which did not load successfully according to log files, copy them from $AIPDOMAIN/input/processed to $AIPDOMAIN/interface/rms, at the same removing the timestamp and changing suffix to the source suffix specified in the two configuration files. The format of the configuration files is: measurename.destination_suffix.source_suffix, e.g. dmx_dscdt_.rpl.ovr.
Ensure all files are formatted correctly.
Ensure that the Load All Hierarchies step ran correctly, and all of the hierarchies' values received from RMS are loaded correctly.
If any of the previous steps did not run correctly, re-run the corresponding step.
Restart the batch.
Notes
This step can be run in parallel with Load Measures with AIP Online Data.
Also, when this script is run for the first time, two measures (dm0_pmsendsrc.txt and dm0_pmsstasrc.txt) are not populated yet so the output for these measures are empty. During the next daily batch run, the RMS sends this information again and updates the measure correctly.
The following sections describe how to Generate and load new item alert measures.
Step Name
create_empty_archive_files
Script Call
create_empty_archive_files.sh
Functional Overview
When AIP Batch is run for the first time, there are no hierarchy alert archive files present from a previous run, which prevents the subsequent step, load_all_newitem_alert_measures.sh, from completing. This step creates empty files that act as placeholders for the archive files.
Technical Details
The script creates the following zero-byte files needed for the hierarchy alerts:
$AIPDOMAIN/interface/prod.dat.last
$AIPDOMAIN/interface/whse.dat.last
$AIPDOMAIN/interface/loc.dat.last
$AIPDOMAIN/interface/hspl.dat.last
|
Note: Other 0-byte alert archive files are created; however, only the files previously listed are required. |
Day on Day Processing
This script performs these steps for day on day processing:
Remove $AIPDOMAIN/interface/*.last
Call UNIX touch to create:
$AIPDOMAIN/interface/prod.dat.last
$AIPDOMAIN/interface/whse.dat.last
$AIPDOMAIN/interface/loc.dat.last
$AIPDOMAIN/interface/hspl.dat.last
Appropriate Batch Run (First Time, Daily, or Both)
First Time.
Prerequisites
None.
Restart/Recovery
If create_empty_archive_files.sh fails, perform the following steps:
Examine the log files to determine the cause of the failure.
Correct any identified setup or environment issues.
Restart the batch.
Step Name
create_alerts
Script Call
load_all_newitem_alert_measures.sh
Functional Overview
Each day, alerts must be generated to inform you that new foundation data was loaded into AIP. Once visible in DM Online, the alert prompts you to set up the supply chain for the new data.
The alerts are also used by AIP RPAS batch and DM Oracle batch to perform new hierarchy specific processing, such as Demand Group assignment, Profile assignment, and Store Source assignment.
Technical Details
This step generates AIP Online and AIP RPAS batch alerts. This step compares the new hierarchy data files with the previous set of hierarchy data files (stored as <hierarchy>.dat.last). If it is a first time aip_batch.sh run, the comparison is against empty <hierarchy>.dat.last files created in a previous first-day step, create_empty_archive_files.sh.
Five batch alerts are generated.
| Alert Measure | Label |
|---|---|
| dm0_new | New Stores |
| dm0_newspl | New Supplier Alert |
| dm1_new | New Warehouses |
| dmx_newprd | New Commodities |
| dmx_newpsz | New Commodity-Pack Sizes |
Day on Day Processing
This script performs these steps for day on day processing:
The script generates RPAS batch alerts by using load_one_newitem_alert_measure.sh script.
load_one_newitem_alert_measure.sh compares the old hierarchy, which was saved as hierarchy.dat.last with the new hierarchy that was loaded earlier to obtain new alerts. If one of the files does not exist for comparison, an empty file is generated and then loaded.
The script uses printArray binary to obtain dimensions, hierarchy, starting position, and the width of the alert. It also compares the hierarchy.last.dat with hierarchy.dat file. The difference is saved as measurename.rpl in the input folder of the DM domain. The generated alert measures are then loaded using the loadmeasure binary.
Once the comparison is complete and the alerts are created, the current $AIPDOMAIN/interface/<hierarchy>.dat files are renamed to $AIPDOMAIN/interface/<hierarchy>.dat.last for the next day's alert generation.
This script calls the following script:
load_one_newitem_alert_measure.sh
Appropriate Batch Run (First Time, Daily, or Both)
First Time
Daily
Prerequisites
This step can only run if the load_all_hierarchies.sh script ran successfully.
Restart/Recovery
If this script fails, perform the following steps:
Examine the log files to determine the cause of the failure.
Correct any identified setup or environment issues.
Check to see if the following measures are flagged correctly based on the new data passed from RMS or AIP Online:
dm0_new
dm0_newspl
dm1_new
dmx_newprd
dmx_newpsz
If any of the previous measures were not flagged correctly, manually update the measures with the correct value:
1 = True
0 = False
If necessary, ftp the *.txt files from the external system to $AIPDOMAIN/interface/external.Restart the batch.
The following sections describe how to Load external system measure data into AIP RPAS.
Step Name
load_non_rms_external
Script Call
load_non_rms_external.sh
Functional Overview
This step is used to load non-forecast measures from external sources other than RMS.
Technical Details
This script is a wrapper for load_non_rms_files.sh passed with a command line argument of external. This subscript loads the early arriving non-RMS external system data into the RPAS domain. See "Load Replenishment Inventory Data" for information about late arriving non-RMS external system data.
Day on Day Processing
This script performs these steps for day on day processing:
Create a list of <measure>.ovr file names by reading $AIPDOMAIN/interface/config/external/measdata_from_external.config, and converting all suffixes to ovr.
For each of the <measure>.ovr file names in the previous list that refer to existing files in directory $AIPDOMAIN/interface/external:
Move the <measure>.ovr file to directory $AIPDOMAIN/input
Call, in parallel, loadmeasure.sh to load measure <measure> with data from <measure>.ovr.
This script or its sub-script calls the following scripts:
load_non_rms_files.sh
loadmeasure.sh (called by load_non_rms_files.sh)
Appropriate Batch Run (First Time, Daily, or Both)
First Time
Daily
Prerequisites
This step must not be initiated until successful completion of the following:
check_process_external_data.sh
load_all_hierarchies.sh
Restart/Recovery
If this script fails, perform the following steps:
Examine the log files to determine the cause of the failure.
If log files show a measure file did not load properly, but that measure file is already moved to $AIPDOMAIN/input/processed, move the file back to $AIPDOMAIN/interface/external without a timestamp. Files which log files show loaded correctly do not need to be moved back.
Correct any identified setup or environment issues.
If necessary, restart the batch from this step.
|
Note: This script may be run in parallel with load_rms_dm_measures.sh and load_onl_data.sh. |
The following sections describe how to commit workbooks before batch run.
Step Name
auto_commit_wkbooks_batch
Script Call
workbook_batch.sh COMMIT
Functional Overview
The user-modified workbooks may be configured to automatically commit during the batch. All SRP and WRP workbooks configured for commit at both global and local domain level are committed in this step. This script may also be run from the command line ad hoc throughout the day by administrators or users.
Technical Details
The workbook_batch.sh script is called to process the SRP and WRP workbooks scheduled for automatic commit. The script uses the RPAS utility wbbatch to automatically commit all SRP and WRP workbooks on the workbook commit queue for each global and local domain. The COMMIT action defined by the single parameter is first performed on the global domain workbooks, then in parallel for each of the local domains.
Day on Day Processing
This script performs these steps for day on day processing:
Call wbbatch to commit all workbooks on the $AIPDOMAIN global domain commit queue.
For each local domain, call wbbatch in parallel to commit all workbooks on each local domain commit queue.
Appropriate Batch Run (First Time, Daily, or Both)
Daily.
Prerequisites
The workday for AIP workbook users must be complete.
Restart/Recovery
If this script fails, perform the following steps:
Examine the log files to determine the cause of the failure.
Correct any identified setup or environment issues.
Restart the batch.
The following sections describe how to perform and export data management calculations.
Step Name
run_partial_dm_batch
Script Call
run_partial_dm_batch.sh
Functional Overview
During a first-time run, execute a partial Data Management RPAS Batch process to establish the planning horizons used by AIP RPAS batch, to create and assign warehouse profiles, and to set store source values.
Technical Details
The Data Management binaries dmcreateprf, dmplanhrzn, dmassignprf, and dmcatchup are executed in their entirety.
Day on Day Processing
This script performs these steps for day on day processing:
Runs dmcreateprf.sh shell script wrapper to the dmcreateprf AIP binary on the $AIPDOMAIN. This assigns the default Store Order Cycle and all warehouses to automatically created Warehouse Profiles.
For each local domain of the RPAS global domain $AIPDOMAIN, runs the dmplanhrzn.sh and dmassignprf.sh shell script wrappers to the dmplanhrzn and dmassignprf AIP binaries. The two scripts are run in series, in the background, for each local domain, such that each local domain is processed in parallel. After all instances are started, the script waits for all instances to complete.
For each local domain of the RPAS global domain $AIPDOMAIN, runs the dmcatchup.sh shell script wrapper to the dmcatchup AIP binary. The script is run in the background for each local domain such that each local domain is processed in parallel. After all instances are started, the script waits for all instances to complete.
This Script Calls these Scripts:
dmcreateprf.sh
dmplanhrzn.sh
dmassignprf.sh
dmcatchup.sh
Appropriate Batch Run (First Time, Daily, or Both)
First Time.
Prerequisites
This step must not be initiated until successful completion of the following:
Set Implementation Parameters
Verify and Process Data from External Systems
Load All Hierarchies
Load Measure Data
Load Non-RMS External Data
Generate Batch and Online Alerts
Restart/Recovery
If this step fails, perform the following steps:
Examine the log files to determine the cause of the failure.
Correct any identified setup or environment issues.
If there is a problem with the dm1_prfhme measure content, then clear the measure so that the next attempt at overlay load does not have any leftover data from the previous erroneous load attempt.
Restart the batch.
Step Name
run_dm_batch
Script Call
dmb_master.sh
Functional Overview
DM RPAS batch is a precursor to the Supply Chain Replenishment Planning (SCRP) calculations. It performs a number of setup and maintenance steps that prepare the data for the rest of the batch processes.
The data setup primarily relates to the technical needs of SRP and WRP, known together as SCRP. It also relates to creating various masks or flag measures to ease the processing. Setting up a mask usually involves combining two or more values (for instance; store planning horizon, on-supply dates, and off-supply dates) along with business validation rules in order to produce a single value that can be repeatedly referenced. This keeps the calculation/validation centralized, and it prevents the need for repeating time consuming logic each time the resultant value is needed.
The most notable data setup calculations that are performed include the:
warehouse schedule
store release schedule
store placement schedule
Default Procedures
DM RPAS also performs a number of maintenance and default procedures. These include:
Warehouse Profile Creation
New SKU assignment to a warehouse Profile
Store Source assignment—-Also known as Catch up
Setting warehouse ranging statuses
Pre-priced status change
Finally, DM RPAS generates alerts that are not related to new hierarchy values. These alerts are exported to DM Online to inform you that various pieces of the supply chain are incomplete or could not be set to the appropriate default settings by DM RPAS. This generation occurs later in the AIP Batch process, however, and not in this step.
Technical Details
At this stage all of the data is loaded into the RPAS global domain $AIPDOMAIN. Now the dmb_master.sh script is called to execute the DM RPAS batch. DM RPAS batch consists of several modules comprised of Korn shell scripts, RPAS rule groups, and C++ binaries. Each module uses some integration (example, RMS, RDF) and intragration (AIP Oracle/Online) inputs and creates outputs, and many times uses as inputs previous DM RPAS batch module outputs. dmb_master.sh is responsible for beginning the critical path processing of DM RPAS batch, so it is called first.
The Korn shell scripts call a number of sub-scripts, which call a number of binaries and execute a number of rule groups in a particular order to calculate new measures. The order of the execution is important because some of the calculated measures are dependent on previously calculated measures. The name of the binary called from these scripts is the same as the name of the script. For example, dmplanhrzn.sh calls the binary dmplanhrzn.
In a later step, the script dmb_master20.sh, which performs non-critical path processing, is executed.
Day on Day Processing
This script performs these steps for day on day processing:
dmb_master.sh calls the dmb_master10.sh script, which contains calls to several other DM batch scripts and DM rule groups that perform the critical path processing of Data Management batch in the RPAS domain $AIPDOMAIN. Table 5-5 presents a high level summary of the Data Management modules that are executed along with their functionally descriptive name.
Table 5-5 Summary of the Data Management Modules
| Order of Execution | Script / Rule Group | Description |
|---|---|---|
|
1 |
dmcreateprf.sh |
Assigns Store Order Cycle and Warehouses to automatically created Warehouse Profiles. |
|
2 |
rulegroup dm_batch_global |
Calculate Delivery Pattern Default, Non-release Day Default, Non-order Day Default, Non-delivery Day Default. |
|
3 |
dmplanhrzn.sh |
Calculate Planning Horizons. |
|
4 |
dmwhsrc.sh |
Calculate Warehouse Source. |
|
5 |
dmassignprf.sh |
Attempts to assign new SKUs to warehouse profiles. |
|
6 |
dmdirsppflg.sh |
Direct Supply Point Flag. |
|
7 |
dmcatchup.sh |
Store Source Assignment. |
|
8 |
horizonFilter.sh dm1_prdalwsts |
Filter SKU-Warehouse Allowable Status down to Planning Horizon. |
|
9 |
dmcmwhal.sh |
Ranging Warehouses to SKU-pack sizes. |
|
10 |
dmstrordpks.sh |
Calculate Store Ordering Pack Size. |
|
11 |
dmstrordunt.sh |
Calculate Store Ordering Unit. |
|
12 |
dmconwhpalmul.sh |
Convert Warehouse Pallet Multiple. |
|
13 |
dmsmlordpksz.sh |
Calculate Smallest Ordering Pack Size. |
|
14 |
dmdgrspec.sh |
Calculate Demand Group Specifier. |
|
15 |
dmpreprcstchg.sh |
Identify Pre-Priced Status Change. |
|
16 |
dminheritattr.sh |
Inherit Attributes. |
This script calls the following script:
dmb_master10.sh
Appropriate Batch Run (First Time, Daily, or Both)
Daily.
Prerequisites
This step must not be initiated until successful completion of the following:
load_non_rms_external.sh
load_all_newitem_alert_measures.sh
load_rms_dm_measures.sh
load_online_measures.sh
Restart/Recovery
If this script fails, perform the following steps:
Examine the log files to determine the cause of the failure. This step generates many log files. Navigate through the BSA logging directory structure to find the log file corresponding to the DM batch script or binary which reported an error.
Correct any identified setup or environment issues.
Restart the batch.
Step Name
export_dm_data
Script Call
export_dm_data.sh
Required Parameters
firstTime (true | false)
Functional Overview
Certain hierarchy and measure data are required by AIP Online for the users to set up the supply chain. The following data must be made available in a set of flat files that follow an agreed AIP RPAS/AIP Online file format:
hierarchy data
measure data calculated in Data Management during the AIP RPAS batch
These are exported from the AIP RPAS domain and bundled for pickup by the client's custom processes to transfer the data to the AIP Online server, for processing by AIP Online's initial batch processes.
Technical Details
The export_dm_data.sh script is called. This script handles exporting the necessary AIP RPAS hierarchy and measure data into flat files formatted for AIP Online.
Day on Day Processing
This script performs these steps for day on day processing:
Call the script export_aip_hiers.sh.
Copies Supplier and Profile hierarchy files into $AIPDOMAIN/interface/export.Prepares Product, Location and Warehouse hierarchy files for export to AIP on Oracle DB by reducing data files to a prearranged selection of columns.
Call the script send_dm_measures_to_online.sh.
This script exports the Data Management measures required for export to AIP Online and copies them to $AIPDOMAIN/interface/export.
It then packages the exported hierarchy and measure data files into the file $AIPDOMAIN/interface/export/dm.tar.Z, a compressed archive that is processed by AIP Online's initial batch step after the client transfers the data from AIP RPAS to AIP Online using a non-AIP process.
Finally this script touches the marker $AIPDOMAIN/interface/export_dm_data indicating that the export has completed. This marker is used by the next day's execution of process_external_data.sh, to determine if the previous day's export was successful.
This Script Calls these Scripts:
export_aip_hiers.sh
send_dm_measures_to_online.sh
Appropriate Batch Run (First Time, Daily, or Both)
First Time
Daily
Prerequisites
This step must not be initiated until successful completion of the following:
run_partial_dm_batch.sh (First Time run only)
dmb_master.sh (Daily run only)
Restart/Recovery
If this step fails, perform the following:
Examine the log files to determine the cause of the failure.
Correct any identified setup or environment issues.
Remove all *.dat and *.ref files from the $AIPDOMAIN/interface/export directory.
Remove all dm_* files from the $AIPDOMAIN/interface/export directory.
Restart the batch.
Step Name
check_import_online_schedule
Script Call
check_import_online_schedule.sh
Functional Overview
AIP-O populates the lead time and secondary lead time for all source-destination combinations and places them in the form of a zip file in the ${AIPDOMAIN}/interface/import directory. This script creates *.ovr files from the *.dat files contained in the zip files First it clears all the schedule measures and then it then uses these *.ovr files to populate the schedule measures in the AIP-R domain which are then used in further processing.
Technical Details
The check_import_online_schedule.sh is called. AIP-O places all the schedule information in the form of a zip file, schedule.tar.Z, in the ${AIPDOMAIN}/interface/import directory.This script then unpacks the data contained in schedule.tar.Z to $AIPDOMAIN/interface/import/meas directory. This data is in the form of *.dat files which are then moved to $AIPDOMAIN/input in the form of *.ovr files (overlays) to be used by loadmeasure to load all the schedule information in the AIP-R domain.
Day on Day Processing
This script performs these steps for day on day processing:
The prep_files.sh is invoked with the Schedule_meas_export key that is listed inside $AIPDOMAIN/interface/config/bsa_prep_files.config
This script processes the file schedule.tar.Z contained in ${AIPDOMAIN}/interface/import and unpacks the data contained within to the $AIPDOMAIN/interface/import/meas directory.The data unpacked overwrites any existing files in the directory.
It then checks whether all the required files present in ${AIPDOMAIN}/interface/config/meas/online_to_rpas_schedule.config are present in $AIPDOMAIN/interface/import/meas or not and exits if any of them is missing.
It then moves *.dat files in $AIPDOMAIN/interface/import/meas to *.ovr in $AIPDOMAIN/input for use by loadmeasure.
It then clears the schedule measures for full refresh.
It then runs loadmeaure to load all schedule measures into the AIP-R domain which will be used for further calculations.
This Script Calls the Following Programs:
clearArray (AIP binary)
loadmeasure
This Script Calls these Scripts:
_check_for_required_files
A function defined in bsa_check_for_required_files.sh
prep_files.sh
Appropriate Batch Run (First Time, Daily, or Both)
Daily
Prerequisites
Before running this step, schedule.tar.Z should be imported by AIP-O into AIP-R.
Restart/Recovery
If this step fails, perform the following:
Examine the log files to determine the cause of the failure.
Correct any identified setup or environment issues.
Ensure that schedule.tar.Z is present in ${AIPDOMAIN}/interface/import directory.
Check that all the required files listed in ${AIPDOMAIN}/interface/config/meas/online_to_rpas_schedule.config are present in $AIPDOMAIN/interface/import/meas.
Restart the batch.
Step Name
dmb_master_post
Script Call
dmb_master_post.sh
Functional Overview
After the schedule information (which contains the lead time and the secondary lead time) has been imported from AIP-O into AIP-R, we need to calculate the schedule dependent measures needed for the batch calculations. This step calculates the review time, DDP, ATP days and the Intra-day nightly prep measures.
Technical Details
The dmb_master_post.sh calls dmb_master_post_local.sh on each of the local domains. In turn, the dmb_master_post_local.sh runs the rule groups that run to calculate the measures needed for further processing of the batch. Since these rule groups require Lead Time, they can only run after importing schedule from AIP-Online.
Day on Day Processing
The dmb_master_post.sh calls dmb_master_post_local.sh which in turn runs the rule groups to populate the necessary measures for the batch calculations.
Table 5-6 presents lists the rule groups that are run along with their functionally descriptive name.
Table 5-6 Rule Groups for Day on Day Processing
| Order of Run | Script / Rule Group | Description |
|---|---|---|
|
1 |
rulegroup calcAtpMaskDdpRt |
Calculate Review Time, DDP and ATP days |
|
2 |
rulegroup dm_batch_local_p |
Calculate all schedule dependent measures |
|
3 |
rulegroup scrp_pre1 |
Calculate all supply-chain parameters |
|
4 |
rulegroup id_nightlyPrep |
Calculate Max Lead Time and Replan list for Intra-day |
This Script Calls This Script:
dmb_master_post_local
Appropriate Batch Run (First Time, Daily, or Both)
Daily
Prerequisites
This step must not be initiated until successful completion of the following:
check_import_online_schedule.sh
Restart/Recovery
If this step fails, perform the following:
Examine the log files to determine the cause of the failure.
Correct any identified setup or environment issues.
Check that the previous step, check_import_online_schedule.sh ran successfully.
Restart the batch.
The following sections describe the process of external integration forecast data processing and load into AIP RPAS.
Step Name
check_load_forecast_data
Script Call
check_load_forecast_data.sh
Optional Parameters
-h: to display script usage
Functional Overview
AIP manages pulling stock through the supply chain just in time to meet the expected demand. It does not calculate the forecasted store demand, so it must load the calculated demand forecasts for the stores from a demand forecasting system, usually RDF.
Technical Details
This script first checks for files listed as required in the configuration file $AIPDOMAIN/interface/config/forecast/forecastdata_from_external.config. These files must exist in directory $AIPDOMAIN/interface/forecast. Then the script moves both the required and optional files listed in the configuration file to the $AIPDOMAIN/input directory before calling loadmeasure to load each.
Day on Day Processing
This script performs these steps for day on day processing:
Verify that all files listed as required in $AIPDOMAIN/interface/config/forecast/forecastdata_from_external.config exist in $AIPDOMAIN/interface/forecast.
Create a list of <measure>.ovr file names by reading $AIPDOMAIN/interface/config/forecast/forecastdata_from_external.config, and converting all suffixes to ovr.
For each of the <measure>.ovr file names in the previous list that refer to existing files in directory $AIPDOMAIN/interface/external:
Move the <measure>.ovr file to directory $AIPDOMAIN/input.
Call, in parallel, loadmeasure to load measure <measure> with data from <measure>.ovr.
This Script Calls these Scripts:
_check_for_required_files (function in bsa_check_for_required_files.sh)
load_non_rms_files.sh
loadmeasure.sh (called by load_non_rms_files.sh)
Appropriate Batch Run (First Time, Daily, or Both)
Daily only.
Prerequisites
This step must not be initiated until successful completion of the following:
Forecast data is available from the external system (RDF).
Restart/Recovery
If this script fails, perform the following steps:
Examine the log files to determine the cause of the failure.
Correct any identified setup or environment issues.
Ftp the *.txt files from the forecasting system to $AIPDOMAIN/interface/forecast.
Restart the batch.
The following sections describe how to prepare replenishment data and maintain history.
Step Name
purge_low_variability_advance
Script Call
purge_low_variability_advance.sh
Functional Overview
Time-series data measures that hold values that change infrequently in time are stored in a very efficient, specialized encoding that takes advantage of this structure. In order for the AIP calculations to make use of these measures, however, they must be adjusted for the current date and relevant period of history for which AIP calculations are to be performed. This adjustment is a combination of purging information in the past that is too old, while simultaneously advancing key encoded values to the beginning of the relevant time window so that they are not lost. This adjustment must be performed at least once on the day of, and as a precursor to, the running of replenishment calculations.
Technical Details
Some of the data affected by this script is stored at the master level of the domain. Some is stored at the subdomain level. At both the global and the local domain level, the purge process is driven by the aipcmd binary, which processes the command files purgeLowVariabilityAdvanceGlobal.xml and purgeLowVariabilityAdvanceLocal.xml. These XML resource files contain the list of measures on which the purge and advance operation applies at each level. Please see the two XML files, located in $RPAS_HOME/applib/resources, for the lists of measures to which this action applies.
Day on Day Processing
This script performs these steps for day on day processing:
Determine the list of local domains under $AIPDOMAIN.
Call the aipcmd binary with the purgeLowVariabilityAdvanceGlobal.xml resource file to purge and advance the data stored at the master level.
For each local domain, call in parallel the binary aipcmd with the purgeLowVariabilityAdvanceLocal.xml resource file to purge and advance the data stored at the subdomain level.
Appropriate Batch Run (First Time, Daily, or Both)
Daily.
Prerequisites
This step must not be initiated until successful completion of the following steps (script calls).
workbook_batch.sh COMMIT
Restart/Recovery
If this script fails, perform the following steps:
Examine the log files to determine the cause of the failure.
Correct any identified setup or environment issues.
Restart the batch.
Step Name
purge_truncate_history
Script Call
for_each_local_domain.sh -p purge_truncate_history.sh [DOMAIN]
|
Note: This complete script call must be made verbatim, including the substring [DOMAIN]. This does not indicate the variable $AIPDOMAIN. Instead, this special string is a token interpreted by for_each_local_domain.sh script as a placeholder for the various local domain paths. for_each_local_domain.sh replaces this token with local domain paths as it calls the purge_truncate_history.sh script for each local domain. |
Functional Overview
AIP retains historical data for a few time-series measures that hold value for display on Company Level Inventory Analysis worksheet found on WRP Interactive Evaluation/SRP Interactive Evaluation workbooks. This worksheet displays a configurable length of historical data. The XML Resource file purgeTruncateHistory.xml, located in $RPAS_HOME/applib/resources contains list of base measures used by the previous worksheet along with required historical age in days. The daily AIP batch truncates any excess historical data found in the measures listed, thus maintaining adequate data in the system.
Technical Details
This step's command line script call is a composite of two scripts, for_each_local_domain.sh and purge_truncate_history.sh, which cause the purge truncate history process to be run in parallel across all local domains. At the local domain level, the process is driven by the aipcmd binary, which processes the command file purgeTruncateHistory.xml. This XML resource file contains the list of measures on which the purge truncate history operation applies. Please see file purgeTruncateHistory.xml, located in $RPAS_HOME/applib/resources for the list of measures to which this action applies.
Day on Day Processing
Script for_each_local_domain.sh performs the following steps:
Determine the list of local domains under $AIPDOMAIN.
For each local domain, call in parallel the script purge_truncate_history.sh and pass it the local domain path. That path is substituted automatically for the [DOMAIN] token by for_each_local_domain.sh.
Appropriate Batch Run (First Time, Daily, or Both)
Daily.
Prerequisites
This step must not be initiated until successful completion of the following steps (script calls).
workbook_batch.sh COMMIT
Restart/Recovery
If this script fails, perform the following steps:
Examine the log files to determine the cause of the failure.
Correct any identified setup or environment issues.
Restart the batch.
Step Name
copy_sister_data
Script Call
for_each_local_domain.sh -p copy_sister_data_local.sh [DOMAIN]
|
Note: See note for Purge Truncate History regarding the use of for_each_local_domain.sh and its interpretation of [DOMAIN]. |
Functional Overview
Data to populate measure positions for newly introduced stores and warehouses is often copied to new positions from the positions of so-called sister stores and warehouses. Sister stores and warehouses have similar characteristics and therefore similar position data to the newly introduced positions. Such copying is declaratively configured for a list of affected measures, based on sister-to-new-position map and copy date. When today equals a store or warehouse's copy date, then for all affected measures, data for each new position that corresponds to the copy date is copied from its defined sister position corresponding to the copy date.
Technical Details
This step's command line script call is a composite of two scripts, for_each_local_domain.sh and copy_sister_data_local.sh, which cause the copying of sister store and warehouse data to be performed in parallel across all local domains. At the local domain level, the process is driven by the aipcmd binary, which processes the command files copySisterStore.xml and copySisterWarehouse.xml, both of which use the CopyLikePositions command. The XML resource files contain the lists of measures on which the sister-copying operations apply. Please see files copySisterStore.xml and copySisterWarehouse.xml, located in $RPAS_HOME/applib/resources, for the lists of measures to which this action applies.
Day on Day Processing
Script for_each_local_domain.sh performs the following steps:
Determine the list of local domains under $AIPDOMAIN.
For each local domain, call in parallel the script copy_sister_data_local.sh and pass it the local domain path. That path is substituted automatically for the [DOMAIN] token by for_each_local_domain.sh.
Appropriate Batch Run (First Time, Daily, or Both)
Daily only.
Prerequisites
This step must not be initiated until successful completion of the following:
workbook_batch.sh COMMIT
load_onl_data.sh
Restart/Recovery
If this script fails, perform the following steps:
Examine the log files to determine the cause of the failure.
Correct any identified setup or environment issues.
Restart the batch.
The following sections describe the process of external integration inventory data processing and load into AIP RPAS.
Step Name
check_process_inventory_data
Script Call
check_process_inventory_data.sh
Optional Parameters
-h: to display script usage.
Functional Overview
RMS is an enterprise solution that provides merchandise hierarchy and organizational setup and maintenance. This data, together with non-RMS external system data, becomes the foundation for the AIP supply chain replenishment. The data is processed as a set of flat files that follow an agreed AIP file format. If the client does not use RMS, but rather some other external system, this data is still required in the same format. AIP validates all of the files to ensure that the required data is present, and massages the files to produce the input required for subsequent steps of the AIP RPAS batch. AIP divides the integration data into two categories: early files and late files. The batch schedule for AIP may aim to maximize the available time by moving as much workload off the critical path as possible.
For this reason the static data is extracted from RMS, or similar system, before the dynamic transaction data is available. This allows the hierarchies to be loaded into AIP and the DM batch run before the dynamic data is extracted. This step processes the early, static data.
Technical Details
The dynamic measure data are listed in the following table. For AIP RPAS batch to properly process external system data, all of the flat files must follow a particular format, which is explained in the Oracle Retail Advanced Inventory Planning Implementation Guide. The flat files must have a *.txt extension.
| File Name | Description |
|---|---|
| sr0_curinv_[1..n].txt | Store Current Inventory |
| sr0_it_.txt | Store In Transits |
| sr0_oo_.txt | Store On Orders |
| sr0_prdlfe.txt | Store Product Life |
| wr1_curinv.txt | Warehouse Current Inventory |
| wr1_it_.txt | Warehouse In Transits |
| wr1_oo_.txt | Warehouse On Orders |
| wr1_aiw.txt | Warehouse Allocations in the Well |
| wr1_tiw.txt | Warehouse Transfers in the Well |
Day on Day Processing
This script performs these steps for day on day processing:
Verify that all required files have been downloaded. Failure to download any of the required files results in an error and termination of the batch.
If store current inventory sr0_curinv data contains more than one partition, like sr0_curinv_1.txt, sr0_curinv_2.txt., …, sr0_curinv_n.txt, merge all of the partitioned files. Rename single or consolidated data file to sr0_curinvinit.txt.
Rename wr1_curinv.txt to wr1_curinvinit.txt.
Prefix the following measure data with the stocking point prefixes, using construct_ntier_measuredata.ksh:
sr0_curinvinit.txt
sr0_it_.txt
sr0_oo_.txt
wr1_curinvinit.txt
wr1_it_.txt
wr1_oo_.txt
wr1_aiw.txt
wr1_tiw.txt
Using interutil binary, convert from RMS SKU to AIP SKU all RMS-sourced inventory measure data that has been configured to arrive late, and therefore is present to be processed by this script (as opposed to arriving early, and therefore is processed by check_process_external_data.sh). See the earlier script and the Oracle Retail Advanced Inventory Planning Implementation Guide for details on this configuring. Note the AIP configuration is to have all dynamic data listed in the previous table arrive as late.
This Script Calls these Scripts:
_check_for_required_files (defined in bsa_check_for_required_files.sh)
process_inventory_data.sh
Appropriate Batch Run (First Time, Daily, or Both)
Daily only.
Prerequisites
This step must not be initiated until successful completion of the following:
All data files from the previous table should be copied by the client's batch scheduler into the $AIPDOMAIN/interface/rms directory. Some of the data is required, and some is optional. Reference the $AIPDOMAIN/interface/config/external/latefiles.config for requirements.
Restart/Recovery
If the process_inventory_data.sh script failed, perform the following steps:
Examine the log files to determine the cause of the failure.
Correct any identified setup or environment issues.
Re-copy or re-FTP all required files listed in $AIPDOMAIN/interface/config/external/latefiles.config into the $AIPDOMAIN/interface/rms directory. The new copies should overwrite the existing files in this directory.
Restart the batch.
Notes
This step can be run in parallel with Export DM and OM Online and all aip_batch.sh steps up to scrp.sh.
Step Name
load_replenishment_data
Script Call
load_replenishment_measures.sh
Functional Overview
This script preprocesses and loads into the RPAS domain all store and warehouse replenishment measure data that come from RMS or other external inventory system.
Technical Details
This script loads into $AIPDOMAIN all Store and Warehouse measure data in $AIPDOMAIN/interface/rms. This step also loads the late arriving non-RMS external data.
Day on Day Processing
This script performs these steps for day on day processing:
Call loadmeasure.sh (a script wrapper for loadmeasure RPAS binary) on the measure data files corresponding to the Replenishment measure data received from the inventory system (example, RMS). The measures loaded are listed in the following configuration files:
$AIPDOMAIN/interface/config/rms/srp_rms_measures.config
$AIPDOMAIN/interface/config/rms/wrp_rms_measures.config
Note all measures are loaded as full replacement (.rpl). This is not intended to be configurable due to functional requirements.
Call load_non_rms_files.sh on the data files corresponding to the late arriving non-RMS external measure data files in the $AIPDOMAIN/interface/external.
This Script Calls these Scripts:
loadmeasure.sh
load_non_rms_files.sh
Appropriate Batch Run (First Time, Daily, or Both)
Daily.
Prerequisites
This step must not be initiated until successful completion of the following:
All steps through the load_all_hierarchies.sh script.
This step can be run in parallel with Load Measures with AIP Online Data.
Restart/Recovery
If this script fails, perform the following steps:
Examine the log files to determine the cause of the failure.
Correct any identified setup or environment issues.
Ensure that the *.txt files are transferred through FTP by client scheduled process from RMS to the correct location.
Ensure all RMS file are present.
Ensure all files are formatted correctly.
Ensure that the Load All Hierarchies step ran correctly, and all of the hierarchies' values received from RMS are loaded correctly.
Restart the batch.
The following sections describe how to calculate and export the replenishment plan.
Step Name
run_replenishment
Script Call
scrp.sh
Functional Overview
Replenishment and Reconciliation is part of the AIP batch run which generates a Receipt Plan for Warehouses and Stores across the length of the horizon. The final output from this batch process is 1) Constrained Receipt Plan for Warehouses and Stores across the Fixed Period. 2) Unconstrained Receipt Plan for Warehouses and Stores across the post Fixed period up to the end of the horizon.
Technical Details
This process is run by running the master script scrp.sh. This script initiates the batch run on global and local domains by first calling the scrp_global.sh on the global domain and then simultaneously calling the scrp_local.sh on all local domains. The global and local scripts internally invoke a set of rule groups according to the sequence subsequently described. Each rule group is responsible for performing a specific step in the supply chain replenishment planning process.
Table 5-7 lists the scripts used for the Replenishment/Reconciliation batch run.
Table 5-7 Scripts Used for the Replenishment/reconciliation Batch Run
| Script Name | Description |
|---|---|
|
scrp.sh |
This script calls scrp_global.sh first on the global domain and then calls scrp_local.sh on all local domains |
|
scrp_global.sh |
Runs the batch on the global domain |
|
scrp_local.sh |
Runs the batch on local domains |
Table 5-8 lists all of the rule groups involved in the AIP Replenishment and Reconciliation batch process.
Table 5-8 Rule Groups Involved In the AIP Replenishment & Reconciliation Batch Process
| Rule Group | Description |
|---|---|
|
Global Rule Groups |
This rule group is called by the scrp_global.sh script. |
|
scrp_pre_glb |
Generates Forecast percentages, and sets store singles flag. |
|
Local Rule Groups |
The following rule groups are called by scrp_local.sh script. |
|
scrp_StrDynamic |
Runs Store Dynamic Safety Stock Statistical Calculation. |
|
scrp_WhDynamic |
Runs Warehouse Dynamic Safety Stock Statistical Calculation. |
|
scrp_pre2 |
Runs all the pre replenishment steps for AIP. |
|
scrp_replPH |
Runs the replenishment batch run within the planning horizon and generates an unconstrained receipt plan. |
|
scrp_invCpPH |
Restricts the unconstrained plan of stores within the planning horizon to inventory caps set by user on workbook. The demand forecasted on the warehouse remains uncapped or the True Demand. |
|
scrp_prReconcile |
Runs pre reconciliation steps for AIP. |
|
scrp_reconcile |
Runs the shortfall, SPQ and stockless to warehouse reconciliation when the demand is greater than the available inventory at the source and generates a constrained receipt plan. |
|
scrp_reconcSub |
Runs the substitution reconciliation and substitutes alternate allowed pack sizes when there is still some unmet demand from destinations. |
|
scrp_pushToStore |
Runs the stockless reconciliation at store destinations for stockless items and pushes the excess quantity to the stores. |
|
scrp_invCpRec |
Checks if the capped plan was reduced further due to shortfall reconciliation and adjusts the warehouse demand accordingly. |
|
scrp_replPstFxd |
Runs the replenishment batch run post fixed period and generates an unconstrained receipt plan for post fixed period. |
|
scrp_invCpPstFxd |
Restricts the post fixed period unconstrained plan of stores to inventory caps set by user on workbook. |
|
WipConvOrders |
Used to map warehouse to warehouse chamber. |
Day on Day Processing
scrp.sh script is the master script to be called once on the global domain. It calls scrp_global.sh on the global domain first and then calls scrp_local.sh on all local domains.
Appropriate Batch Run (First Time, Daily, or Both)
Daily.
Prerequisites
This step must not be initiated until successful completion of the following:
load_replenishment_measures.sh
check_load_forecast_data.sh
dmb_master.sh
for_each_local_domain.sh -p copy_sister_data_local.sh [DOMAIN]
Restart/Recovery
If this script fails, perform the following steps:
Examine the log files to determine the cause of the failure.
Correct any identified setup or environment issues.
Run dmb_master.sh.
Restart the batch.
Step Name
export_replenishment_data
Script Call
for_each_local_domain.sh -p export_scrp_inter_meas_local.sh [DOMAIN]
|
Note: See note for Purge and Advance Low-Variability Data regarding the use of for_each_local_domain.sh and its interpretation of [DOMAIN]. |
Functional Overview
The replenishment plan's planned orders from suppliers and transfers from warehouses must be exported from populated measures into files suitable for interfacing with AIP Online. In this batch step, the exports are performed independently in each local domain, resulting in each having its own copy of the following export files placed in the local domain output directory:
| Script Name | Description |
|---|---|
| strsplrord.dat | Supplier to store orders for release today through the planning horizon. |
| strsplrord.dat1 | Contingency supplier to store orders for release tomorrow only. |
| strwhord.dat | Warehouse to store transfers for release today. |
| strwhord.dat1 | Contingency warehouse to store orders for release tomorrow only. |
| vendor_to_wh_order.dat | Supplier to warehouse orders for release today through the planning horizon. |
| wh_to_wh_transfer.dat | Warehouse to warehouse transfers for release today through the planning horizon. |
Technical Details
This step's command line script call is a composite of two scripts, for_each_local_domain.sh and export_scrp_inter_meas_local.sh, which together cause the exporting of order and transfer data to be performed in parallel across all local domains. At the local domain level, the process is driven by the aipcmd binary, which processes the XML resource command files to produce the parenthesized output files:
exportPlanStrSplrOrd.xml (strsplrord.dat)
exportPlanStrSplrOrd1.xml (strsplrord.dat1)
exportPlanStrWhOrd.xml (strwhord.dat)
exportPlanStrWhOrd1.xml (strwhord.dat1)
exportPlanWhOrd.xml (vendor_to_wh_order.dat)
exportPlanWhXfer.xml (wh_to_wh_transfer.dat)
These XML resource files all make use of the ExportPlan command to perform the specialized data exports.
Day on Day Processing
Script for_each_local_domain.sh performs the following steps:
Determine the list of local domains under $AIPDOMAIN.
For each local domain, call in parallel the script export_scrp_inter_meas_local.sh and pass it the local domain path. That path is substituted automatically for the [DOMAIN] token by for_each_local_domain.sh.
Appropriate Batch Run (First Time, Daily, or Both)
Daily.
Prerequisites
This step must not be initiated until successful completion of the following:
scrp.sh
Restart/Recovery
If this script fails, perform the following steps:
Examine the log files to determine the cause of the failure.
Correct any identified setup or environment issues.
Restart the batch.
Step Name
send_replenishment_to_online
Script Call
send_scrp_measures_to_online.sh
Functional Overview
Planned orders and transfers, exported separately per local domain in the Export Replenishment Data step, are combined, tarred, and compressed for interfacing with AIP Online.
Technical Details
In this batch step, the filenames listed in the global domain's interface/config/meas/scrp_export.config file are located in each local domain's output directory and concatenated into like-named files in the global domain's interface/export directory.
Day on Day Processing
This script performs these steps for day on day processing:
Verify the existence and writeability of the global domain's interface/export directory, the destination of the concatenated export files.
For each of the files listed in the global domain's interface/config/meas/scrp_export.config file, delete any existing instance in the global domain's interface/export directory, then iterate over the list of local domains, concatenating each instance of the file found in the local domain's output directory into the global interface file of the same name in global domain's interface/export directory.
Compress each global domain export file, package them all into a single tar file, then compress the tar file into a single file: $AIPDOMAINinterface/export/srp.tar.Z.
Appropriate Batch Run (First Time, Daily, or Both)
Daily.
Prerequisites
This step must not be initiated until successful completion of the following:
for_each_local_domain.sh -p export_scrp_inter_meas_local.sh [DOMAIN]
Restart/Recovery
If this script fails, perform the following steps:
Examine the log files to determine the cause of the failure.
Correct any identified setup or environment issues.
Restart the batch.
Step Name
post_dcrp_import
Script Call
post_dcrp_import.sh
Functional Overview
AIP-O populates the Cross Dock Constraint Receipt Plan(DCRP) measures and places them in the form of a zip file in the ${AIPDOMAIN}/interface/import directory. This script creates *.ovr files from the *.dat files contained in the zip file. First it clears all the DCRP output measures and then it then uses these *.ovr files to populate these measures in the AIP-R domain which are then used in further processing.
Technical Details
The post_dcrp_import.sh is called. AIP-O places all the DCRP output information in the form of a zip file, dcrp.tar.Z, in the ${AIPDOMAIN}/interface/import directory. This script then unpacks the data contained in dcrp.tar.Z to $AIPDOMAIN/interface/import/meas directory. This data is in the form of *.dat files which are then moved to $AIPDOMAIN/input in the form of *.ovr files (overlays) to be used by loadmeasure to load all the DCRP outputs in the AIP-R domain.
Day on Day Processing
This script performs these steps for day on day processing:
The prep_files.sh is invoked with the DCRP_meas_export key that is listed inside $AIPDOMAIN/interface/config/bsa_prep_files.config
This script processes the file dcrp.tar.Z contained in ${AIPDOMAIN}/interface/import and unpacks the data contained within to the $AIPDOMAIN/interface/import/meas directory.The data unpacked overwrites any existing files in the directory.
It then checks whether all the files present in ${AIPDOMAIN}/interface/config/meas/post_dcrp_import.config are present in $AIPDOMAIN/interface/import/meas or not and exits if any of them is missing.
It then moves *.dat files in $AIPDOMAIN/interface/import/meas to *.ovr in $AIPDOMAIN/input for use by loadmeasure.
It then clears the DCRP measures for full refresh.
It then runs loadmeasure to load all DCRP output measures into the AIP-R domain which will be used for further calculations.
This Script Calls the Following Programs:
clearArray (AIP binary)
loadmeasure
This Script Calls these Scripts:
_verify_file_exists
A function defined in bsa_verify.sh
prep_files.sh
Appropriate Batch Run (First Time, Daily, or Both)
Daily
Prerequisites
Before running this step, dcrp.tar.Z should be imported by AIP-O into AIP-R.
Restart/Recovery
If this step fails, perform the following:
Examine the log files to determine the cause of the failure.
Correct any identified setup or environment issues.
Ensure that dcrp.tar.Z is present in ${AIPDOMAIN}/interface/import directory.
Check that all the files listed in ${AIPDOMAIN}/interface/config/meas/post_dcrp_import.config are present in $AIPDOMAIN/interface/import/meas.
Restart the batch.
The following sections describe how to load the scaled replenishment plan.
Step Name
post_ocs_import
Script Call
post_ocs_import.sh
Functional Overview
Modifications made to the warehouse plan by the Scaling module are imported so that the future projections of inventory and ordering, which are displayed in workbooks and reflected in alert calculations, are based on the final planned order quantities.
This step can be excluded from the batch if the business does not use the Scaling module within AIP. This step must not run if the corresponding AIP Oracle database extract is not run to generate the data files.
Technical Details
None.
Day on Day Processing
This script performs these steps for day on day processing:
prep_files.sh is called to process the AIP Oracle scaling export. The prep_files.sh script is invoked with the key OCS_meas_export listed inside $AIPDOMAIN/interface/config/bsa_prep_files.config. This processes the file ocs.tar.Z and unpacks the data contained within to the $AIPDOMAIN/interface/import/meas directory.
Before the archive is unpacked, a backup of the file is created in the
$BSA_ARCHIVE_DIR directory. The backup filename is ocs.tar.Z.<timestamp>.
After the archive is unpacked, the archive file is removed from $AIPDOMAIN/interface/import.
The data unpacked overwrites existing files in the directory.
Verify that all files have been downloaded and unpacked. Failure to download any of the files results in an error and termination of the batch. Required files are found in post_ocs_import.config.
If the SPQ Date Type measure holds the value for Ship Date then the delivery date in the file containing Executed SPQ (SPEQ) quantities is converted to TODAY, the ship date. The file extension is then changed to .inc (incremental) to cause the values loaded into the same position to be added together. This need can arise when the SPQs are applied to the Ship week and multiple delivery dates have the same release (ship) date.
The measures to be loaded are cleared and then loaded with data from the files.
Appropriate Batch Run (First Time, Daily, or Both)
Daily.
Prerequisites
This step must not be initiated until successful ftp or copy of the ocs.tar.Z file.
Restart/Recovery
If this script fails, perform the following steps:
Examine the log files to determine the cause of the failure.
Correct any identified setup or environment issues. If necessary, copy and rename the archived version of the ocs.tar.Z file from the archive directory into the $AIPDOMAIN/interface/import directory.
Restart the batch.
The following sections describe how to perform post-replenishment calculations.
Step Name
run_replenishment_post_processing
Script Call
for_each_local_domain.sh -p scrp_post_local.sh [DOMAIN]
|
Note: See note for Purge and Advance Low-Variability Data regarding the use of for_each_local_domain.sh and its interpretation of [DOMAIN]. |
Functional Overview
Replenishment post processing generates Safety Stock, Projected Inventory, Receipt Point, and Receive Up To Level values across the horizon. These values are calculated on the fly during the Replenishment and Reconciliation stage but are not written to a measure as the demand and inventory picture changes across the Fixed Period. Once the constrained receipt plan is generated, the correct demand and inventory levels are known for the post processing to generate the previous values across the horizon.
Also, when order and container scaling is implemented, it updates Receipt Plan, Forecasted Receipts, Demand Output, and Total Forecast Demand.
Technical Details
Table 5-9 lists the scripts used for the Replenishment Post Processing batch run.
Table 5-9 Scripts Used for the Replenishment Post Processing Batch Run
| Script Name | Description |
|---|---|
|
scrp_post_local.sh |
This script calls scrp_post rule group on the local domains which actually does the post processing. |
Table 5-10 gives a list of all the rule groups involved in the AIP Post Replenishment & Reconciliation batch process.
Table 5-10 Rule Groups Used In the AIP Post Replenishment & Reconciliation Batch Process
| Rule Groups | Description |
|---|---|
|
Local Rule Groups |
The following rule groups are called by scrp_post_local.sh script. |
|
scrp_post_ocs1 |
Copies replenishment data to the pre-scaling measures. |
|
scrp_post_ocs2 |
Adds Scaling adjustments to the replenishment data. |
|
scrp_post |
Performs the post processing on local domains and generates inputs for calculating historical measures and alerts. |
|
scrp_histmaint |
Preserves data for certain measures for historical purposes which are especially useful for alerts. |
|
scrp_cleartemp |
Clears some of the stored inputs calculated in scrp_post now that its data was preserved in scrp_histmaint. |
Day on Day Processing
Script for_each_local_domain.sh performs the following steps:
Determine the list of local domains under $AIPDOMAIN.
For each local domain, call in parallel the script scrp_post_local.sh script sh and pass it the local domain path. That path is substituted automatically for the [DOMAIN] token by for_each_local_domain.sh.
Appropriate Batch Run (First Time, Daily, or Both)
Daily.
Prerequisites
This step must not be initiated until successful completion of the following:
scrp.sh
post_ocs_import.sh (if implementing order and container scaling)
Restart/Recovery
This step must not be initiated until successful completion of the following:
scrp.sh
post_ocs_import.sh (if implementing order and container scaling)
Restart/Recovery
If this script fails, perform the following steps:
Examine the log files to determine the cause of the failure.
Correct any identified setup or environment issues.
If order and container scaling is not implemented: Restart the batch.
If order and container scaling is implemented:
Determine the local domains that had an issue.
Determine which of the previous rule groups ran successfully.
If none ran successfully: restart the batch.
If some ran successfully: Re-run manually the rule groups that did not run successfully. Then restart the batch.
The following sections describe how to calculate and export data management alerts.
Step Name
run_dm_alerts
Script Call
dmb_master_alerts.sh
Required Parameters
firstTime (true | false)
Functional Overview
DM RPAS generates alerts that are not related to new hierarchy values. These alerts are exported to DM Online to inform you that various pieces of the supply chain are incomplete or could not be defaulted by DM RPAS.
Technical Details
Now the dmb_master_alerts.sh script is called to execute the DM RPAS batch, non-critical path, including the alerts generation. As before, this process is comprised of several modules that use Korn shell scripts and C++ binaries in a particular order to calculate new measures. The order of the execution is important because some of the calculated measures are dependent on previously calculated measures.
Day on Day Processing
dmb_master_alerts.sh calls the dmb_master20.sh script, which calls dmb_master21.sh on all local domains, which contains calls (through subscripts) to several other DM batch scripts that perform the non-critical path processing of Data Management batch in the RPAS domain $AIPDOMAIN. Table 5-11 presents a high level summary of the Data Management modules that are executed along with their functionally descriptive name.
Table 5-11 Summary of the Data Management Modules
| Order of Execution | Script / Operation | Description |
|---|---|---|
|
1 |
mace call |
Calculate Warehouse Demand |
|
2 |
dmcmdstralerts.sh |
Commodity/Store Alerts |
|
3 |
horizonFilter.sh |
Prepare time-boxed Product Allowable Status Measure for Use by Missing Data Alert |
|
4 |
dmmsgdatalert.sh |
Missing Data Alert |
|
5 |
dmnasprfalert.sh |
Not Assigned to Profile Alert |
|
6 |
dmdscalert.sh |
Discontinuation Alert |
This Script Calls these Scripts:
xmace
dmb_master20.sh
Appropriate Batch Run (First Time, Daily, or Both)
First Time
Daily
Prerequisites
This step must not be initiated until successful completion of the following:
run_partial_dm_batch.sh (First Time run only)
dmb_master.sh (Daily run only)
Restart/Recovery
If this script fails, perform the following steps:
Examine the log files to determine the cause of the failure.
Correct any identified setup or environment issues.
Restart the batch.
Step Name
export_dm_alerts
Script Call
export_dm_alerts.sh
Required Parameters
FirstTime (true | false)
Functional Overview
The Data Management Alert measures calculated by the processes of dmb_master20.sh are required for import into AIP Online. These are exported from the AIP RPAS domain and bundled for pickup by AIP Online's initial batch processes.
Technical Details
The export_dm_alerts.sh script is called. This script handles exporting the necessary AIP RPAS alert data into flat files formatted for AIP Online.
Day on Day Processing
This script performs these steps for day on day processing:
Call the script export_dm_inter_meas.sh to export the intragration alert data from the calculated alert measures.
Package the exported alert measure data files into the file $AIPDOMAIN/interface/export/dm_alerts.tar.Z, a compressed archive that is imported by AIP Online's initial batch step.
This script calls the following script:
export_dm_inter_meas.sh
Appropriate Batch Run (First Time, Daily, or Both)
First Time
Daily
Prerequisites
This step must not be initiated until successful completion of the following:
dmb_master_alerts.sh
Restart/Recovery
If this script fails, perform the following steps:
Examine the log files to determine the cause of the failure.
Correct any identified setup or environment issues.
Restart the batch.
The following sections describe how to compute replenishment alerts.
Step Name
run_srp_alerts
Script Call
scrp_srp_alerts.sh
Functional Overview
All of the SRP alerts for out-of-stocks and excessive planned orders must be generated by AIP RPAS batch. These alerts allow the retailer to identify potential supply chain problems before they happen so that potential stock-outs and excess inventory problems can be prevented or reduced.
Technical Details
This step runs the SRP Alert calculations after the batch jobs have finished. It is recommended that this part of the system run off the critical path.
During the domain build the following SRP alerts measures are registered in the AIP domain:
| Alert Name | Description |
|---|---|
| sr0_art__1 | Store Alert 1: Large Consecutive Out of Stocks |
| sr0_art__2 | Store Alert 2: Large Out of Stocks Last Night |
| sr0_art__3 | Store Alert 3: Single Store Availability Problems |
| sr0_art__4 | Store Alert 4: High Projected Out of Stock |
| sr0_art__5 | Store Alert 5: Large Non-Consecutive Out of Stocks |
| sr0_art__6 | Store Alert 6: Day on Day Repeat Out of Stocks |
| sr0_art__7 | Store Alert 7: High Projected Low Stocks |
| sr0_art__8 | Store Alert 8: High Planned Orders |
| sr0_art__9 | Store Alert 9: RDF Detail Alert |
| sr0_art__10 | Store Alert 10: No Like SKU Found |
| sr0_arthstsum | Historic Availability Alert |
| sr0_artprjsum | Projected Availability Alerts |
| sr0_ovrstkalt | Overstock Alert |
| sr0_hrdart | High Repeated Dissipation |
| sr0_hdyart | High Dissipation Yesterday |
Day on Day Processing
This script performs these steps for day on day processing:
Execute scrp_glbMsk rule group.
In each local domain, run in parallel these two rule groups:
scrp_preRegAlert
scrp_srpAlerts
This script calls the following script:
xmace
Appropriate Batch Run (First Time, Daily, or Both)
Daily.
Prerequisites
This step must not be initiated until successful completion of the following:
scrp.sh
for_each_local_domain.sh -p scrp_post_local.sh [DOMAIN]
Restart/Recovery
If this script fails, perform the following steps:
Examine the log files to determine the cause of the failure.
Correct any identified setup or environment issues.
Restart the batch.
Notes
This step calculates the basics on which SRP alerts are based. Later, the
replenishment_alerts_post_processing.sh runs the RPAS utility alertmgr to find all alerts registered in the $AIPDOMAIN domain.
Step Name
run_wrp_item_alerts
Script Call
wrp_item_alerts.sh
Functional Overview
The WRP alerts for unmet demand and warehouse capacity issues are generated by AIP RPAS batch. These alerts allow the retailer to identify potential supply chain problems before they happen so that potential stock-outs and excess inventory problems can be prevented or reduced.
Technical Details
This step runs the WRP Alerts after the batch jobs have finished. It recommended that this part of the system run off the critical path.
During the domain build the following WRP Item alerts measures are registered in the AIP domain:
| Alert Name | Description |
|---|---|
| IpSlsCrdAltV | Sales Credit Alert |
| IpDmdCrdAltV | Demand Credit Alert |
| IpOvrStkAltV | Overstock Alert |
| IpRdfAltV | RDF Alert |
Day on Day Processing
This script performs these steps for day on day processing:
Determine the list of local domains under $AIPDOMAIN.
For each local domain, run in parallel the WrpItem_alert rule group.
This script calls the following script:
xmace
Appropriate Batch Run (First Time, Daily, or Both)
Daily.
Prerequisites
This step must not be initiated until successful completion of the following:
scrp.sh
for_each_local_domain.sh -p scrp_post_local.sh [DOMAIN]
Restart/Recovery
If this script fails, perform the following steps:
Examine the log files to determine the cause of the failure.
Correct any identified setup or environment issues.
Restart the batch.
|
Note: This step calculates the basics on which WRP item alerts are based. Later, the replenishment_alerts_post_processing.sh runs the RPAS utility alertmgr to find all alerts registered in the $AIPDOMAIN domain. |
Step Name
run_wrp_network_alerts
Script Call
wrp_network_alerts.sh
Functional Overview
The WRP Network alerts notify the user of various product flow scenarios across user-defined network of SKUs. These alerts highlight potential supply chain problems before they happen, so that potential stock-outs and excess inventory problems can be prevented or reduced.
Technical Details
This step runs the WRP Network Alerts after the batch jobs have finished. It is recommended that this part of the system run after the critical path.
During the domain build the following WRP Network alerts measures are registered in the AIP domain.
| Alert Name | Description |
|---|---|
| IpStkCvrAltV | Stk Cvr Alert (Act In vs. Act Out) |
| IpIbDODAltV | Inbound Day-on-Day Change Alert |
| IpDstObCpcAltV | Outbound Distribution Capacity Alert |
| IpObDODAltV | Outbound Day-on-Day Change Alert |
| IpScDODAltV | Stock Cover Day-on-Day Change Alert |
| IpHldCpcAltV | Warehouse Holding Capacity Alert |
Day on Day Processing
This script performs these steps for day on day processing:
Clear all network alert measures in $AIPDOMAIN.
Determine the list of local domains under $AIPDOMAIN.
For each local domain, run in parallel the WrpNwAlertLocal rule group.
Execute the WrpNwAlertGlobal on the global domain $AIPDOMAIN.
This script calls the following script:
xmace
Appropriate Batch Run (First Time, Daily, or Both)
Daily.
Prerequisites
This step must not be initiated until successful completion of the following:
scrp_srp_alerts.sh
wrp_item_alerts.sh
Restart/Recovery
If this script fails, perform the following steps:
Examine the log files to determine the cause of the failure.
Correct any identified setup or environment issues.
Restart the batch.
|
Note: This script should not be run consecutively on the same day as it affects the day-on-day change alerts. |
Step Name
run_replenishment_alerts_post_processing
Script Call
replenishment_alerts_post_processing.sh
Functional Overview
The WRP Network alerts notify the user of various product flow scenarios across user-defined network of SKUs. These alerts highlight potential supply chain problems before they happen, so that potential stock-outs and excess inventory problems can be prevented or reduced.
In this step, the history is updated to contain the current day's run.
Technical Details
This step finds the WRP Network Alerts after the batch jobs have finished. It recommended that this part of the system run after the critical path.
Day on Day Processing
This script performs these steps for day on day processing:
Call alertmgr to find all generated alerts on $AIPDOMAIN.
Execute the WrpNwAlertGlobal2 on the global domain $AIPDOMAIN.
This script calls the following script:
xmace
Appropriate Batch Run (First Time, Daily, or Both)
Daily.
Prerequisites
This step must not be initiated until successful completion of the following:
wrp_network_alerts.sh
Restart/Recovery
If this script fails, perform the following steps:
Examine the log files to determine the cause of the failure.
Correct any identified setup or environment issues.
Restart the batch.
|
Note: This script should not be run consecutively on the same day as it affects the day-on-day change alerts. |
The following sections describe how to build workbooks after a batch run.
Step Name
auto_build_wkbooks_batch
Script Call
workbook_batch.sh BUILD
Functional Overview
Many of the SRP and WRP workbooks can be configured by the system administrator to be automatically built each night as part of the AIP RPAS batch run. This allows you to enter the worksheets directly without going through the workbook creation wizard. All SRP and WRP workbooks configured for commit at both global and local domain level are committed in this step. This script may also be run from the command line ad hoc throughout the day by administrators or users.
Technical Details
This step uses the RPAS utility wbbatch to automatically build SRP and WRP workbooks. In order to successfully auto-build workbooks, they must be configured through the RPAS client. Refer to the RPAS Administration Guide for information on automatically building workbooks.
Day on Day Processing
This script performs these steps for day on day processing:
Call wbbatch to build all workbooks on the $AIPDOMAIN global domain build queue.
For each local domain, call wbbatch in parallel to build all workbooks on each local domain build queue.
Appropriate Batch Run (First Time, Daily, or Both)
Daily.
Prerequisites
This step must not be initiated until the following steps (scripts) are successfully completed.
scrp_srp_alerts.sh
wrp_item_alerts.sh
wrp_network_alerts.sh
replenishment_alerts_post_processing.sh
Restart/Recovery
If this script fails, perform the following steps:
Examine the log files to determine the cause of the failure.
Correct any identified setup or environment issues.
Restart the batch.
The following sections describe how to run calculations for OBIEE reports.
Step Name
run_reports_calculation
Script Call
run_OBIEE_reports.sh
Functional Overview
The Integrated Inventory Planning (IIP) OBIEE Reports direct the Inventory Analyst's attention to problematic situations summarized by SKU and by warehouse. The reports help direct the user's analysis starting with a summarized view of the problem and providing greater detail at each reporting level. This helps the user to not only identify potential issues quickly but also quickly analyze the size and severity of the issue to prioritize the resolution.
The IIP Reports will integrate data from the following Oracle Retail applications: Advanced Inventory Planning (AIP), Retail Demand Forecasting (RDF), Replenishment Optimization (RO), and Retail Merchandising System (RMS). This step runs the AIP calculations required to support the OBIEE reports desired for IIP.
Technical Details
This step uses the RPAS mace utility to run several rule groups which calculate the reporting measures.
Day on Day Processing
This script performs these steps for day on day processing:
Run xmace wrapper to mace for the following rule groups:
Common Rules
Capacity Report
New SKU Report
Discontinued SKU Report
Alert Dashboard
This script calls the following script:
xmace
Appropriate Batch Run (First Time, Daily, or Both)
Daily.
Prerequisites
This step must not be initiated until the following steps are successfully completed.
run_replenishment_alerts_post_processing
Restart/Recovery
If this script fails, perform the following steps:
Examine the log files to determine the cause of the failure.
Correct any identified setup or environment issues.
Restart the batch.
The following sections describe how to run the AIP dashboard.
Step Name
run_dashboard
Script Call
run_dashboard.sh
Functional Overview
The AIP Dashboard feature is part of AIP Usability enhancements for the RPAS portion of the AIP application. The AIP Dashboard is a view of information relevant to a user, available to them in a high level view, without accessing a workbook first.The Dashboard is intended to provide quick visibility to important data for items of interest to users through the features Product Watchlist, Location Watchlist and Orders about to be executed.The AIP Dashboard is accessed by AIP RPAS users from the Fusion Client after authentication.
Technical Details
The run_dashboard.sh script is called which runs the dashboard rule group on each of the local domains which populates the measures which are used in AIP dashboard.
Day on Day Processing
This script runs the dashboard rule group on the local domains and populates the following dashboard-only measures:
IpPlnRcpV
sr0_pckssday
sr0_pcksswk
sr0_pckrutlday
sr0_pckrutlwk
sr0_pckrpday
sr0_pckrpwk
sr0_pckdmdwk
sr0_pckdmdday
sr0_strttlplnrcpwk
sr0_strprjinvwk
sr0_strprsstkwk
IpWhSSWkV
IpWhRUTLWkV
IpWhRcpPtWkV
IpWhPrjInvWkV
IpTtlDmdV
IpTtlDmdWkV
IpWhPlnRcpWkV
IpWhPlnRcpTmpO
IpWhSSTmpO
IpWhPlnRcpV
IpWhPrjInvV
IpPlnRcpRelV
IpPlnExpRcpDelV
IpWhRcpPtV
IpWhRcpPtTmpO
IpWhRUTLV
IpWhRUTLTmpO
IpWhSSV
wr1_prjinv
sr0_prjinv
sr0_strprjinv
sr0_rcppln
sr0_strttlplnrcp
sr0_strprsstk
IpExpRcpSrcV
This Script Calls this Script:
xmace
Appropriate Batch Run (First Time, Daily, or Both)
Daily
Prerequisites
This step must not be initiated until successful completion of the following:
run_OBIEE_reports.sh
Restart/Recovery
If this step fails, perform the following:
Examine the log files to determine the cause of the failure.
Correct any identified setup or environment issues.
Restart the batch.
