eTRM uses javascript that opens and focuses a separate window to display reports. Your browser does not appear to support javascript. This should not prevent you from using eTRM but it does mean the window focus feature will not work. Please check the contents of other windows on your desktop if you click on a link that does not appear to do anything.

[Home] [Help]

APPS.MSC_CL_COLLECTION dependencies on FND_MESSAGE

Line 96: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');

92: lv_counter number := 1;
93:
94:
95: BEGIN
96: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
97: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'alter_temp_table_by_monitor');
98: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
99:
100: lv_prod_short_name := AD_TSPACE_UTIL.get_product_short_name(724);

Line 97: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'alter_temp_table_by_monitor');

93:
94:
95: BEGIN
96: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
97: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'alter_temp_table_by_monitor');
98: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
99:
100: lv_prod_short_name := AD_TSPACE_UTIL.get_product_short_name(724);
101: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS,'Product short name - ' || lv_prod_short_name);

Line 98: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

94:
95: BEGIN
96: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
97: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'alter_temp_table_by_monitor');
98: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
99:
100: lv_prod_short_name := AD_TSPACE_UTIL.get_product_short_name(724);
101: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS,'Product short name - ' || lv_prod_short_name);
102:

Line 126: FND_MESSAGE.SET_NAME('MSC', 'MSC_ALT_TMP_TABLE_LAUNCH_FAIL');

122: );
123:
124: COMMIT;
125: IF lv_request_id = 0 THEN
126: FND_MESSAGE.SET_NAME('MSC', 'MSC_ALT_TMP_TABLE_LAUNCH_FAIL');
127: FND_MESSAGE.SET_TOKEN('TABLE_NAME', c_rec.table_name);
128: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, FND_MESSAGE.GET);
129: RETURN FALSE;
130: ELSE

Line 127: FND_MESSAGE.SET_TOKEN('TABLE_NAME', c_rec.table_name);

123:
124: COMMIT;
125: IF lv_request_id = 0 THEN
126: FND_MESSAGE.SET_NAME('MSC', 'MSC_ALT_TMP_TABLE_LAUNCH_FAIL');
127: FND_MESSAGE.SET_TOKEN('TABLE_NAME', c_rec.table_name);
128: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, FND_MESSAGE.GET);
129: RETURN FALSE;
130: ELSE
131: lv_req_id(lv_counter) := lv_request_id;

Line 128: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, FND_MESSAGE.GET);

124: COMMIT;
125: IF lv_request_id = 0 THEN
126: FND_MESSAGE.SET_NAME('MSC', 'MSC_ALT_TMP_TABLE_LAUNCH_FAIL');
127: FND_MESSAGE.SET_TOKEN('TABLE_NAME', c_rec.table_name);
128: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, FND_MESSAGE.GET);
129: RETURN FALSE;
130: ELSE
131: lv_req_id(lv_counter) := lv_request_id;
132: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1,'Submitted request ' || lv_req_id(lv_counter) || ', to alter table : ' || c_rec.table_name);

Line 143: FND_MESSAGE.SET_NAME('MSC', 'MSC_ALT_TMP_TABLE_REQ_FAIL');

139: FOR j IN 1..lv_req_id.COUNT LOOP
140: mrp_cl_refresh_snapshot.wait_for_request(lv_req_id(j), 30, lv_out);
141:
142: IF lv_out = 2 THEN
143: FND_MESSAGE.SET_NAME('MSC', 'MSC_ALT_TMP_TABLE_REQ_FAIL');
144: FND_MESSAGE.SET_TOKEN('REQUEST_ID', lv_req_id(j));
145: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, FND_MESSAGE.GET);
146: RETURN FALSE;
147: ELSE

Line 144: FND_MESSAGE.SET_TOKEN('REQUEST_ID', lv_req_id(j));

140: mrp_cl_refresh_snapshot.wait_for_request(lv_req_id(j), 30, lv_out);
141:
142: IF lv_out = 2 THEN
143: FND_MESSAGE.SET_NAME('MSC', 'MSC_ALT_TMP_TABLE_REQ_FAIL');
144: FND_MESSAGE.SET_TOKEN('REQUEST_ID', lv_req_id(j));
145: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, FND_MESSAGE.GET);
146: RETURN FALSE;
147: ELSE
148: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1,'Request ' || lv_req_id(j) || ' successful');

Line 145: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, FND_MESSAGE.GET);

141:
142: IF lv_out = 2 THEN
143: FND_MESSAGE.SET_NAME('MSC', 'MSC_ALT_TMP_TABLE_REQ_FAIL');
144: FND_MESSAGE.SET_TOKEN('REQUEST_ID', lv_req_id(j));
145: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, FND_MESSAGE.GET);
146: RETURN FALSE;
147: ELSE
148: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1,'Request ' || lv_req_id(j) || ' successful');
149: END IF;

Line 336: FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_LAUNCH_PURGER_FAIL');

332:
333: COMMIT;
334:
335: IF lvs_request_id=0 THEN
336: FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_LAUNCH_PURGER_FAIL');
337: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
338: RETURN FALSE;
339: ELSE
340: FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_PURGER_REQUEST_ID');

Line 337: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);

333: COMMIT;
334:
335: IF lvs_request_id=0 THEN
336: FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_LAUNCH_PURGER_FAIL');
337: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
338: RETURN FALSE;
339: ELSE
340: FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_PURGER_REQUEST_ID');
341: FND_MESSAGE.SET_TOKEN('REQUEST_ID', lvs_request_id);

Line 340: FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_PURGER_REQUEST_ID');

336: FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_LAUNCH_PURGER_FAIL');
337: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
338: RETURN FALSE;
339: ELSE
340: FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_PURGER_REQUEST_ID');
341: FND_MESSAGE.SET_TOKEN('REQUEST_ID', lvs_request_id);
342: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
343: END IF;
344:

Line 341: FND_MESSAGE.SET_TOKEN('REQUEST_ID', lvs_request_id);

337: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
338: RETURN FALSE;
339: ELSE
340: FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_PURGER_REQUEST_ID');
341: FND_MESSAGE.SET_TOKEN('REQUEST_ID', lvs_request_id);
342: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
343: END IF;
344:
345: LOOP

Line 342: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

338: RETURN FALSE;
339: ELSE
340: FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_PURGER_REQUEST_ID');
341: FND_MESSAGE.SET_TOKEN('REQUEST_ID', lvs_request_id);
342: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
343: END IF;
344:
345: LOOP
346: /* come out of function only when the MSCPDCP is complete - reqd for Collections incompatibility */

Line 359: FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_LAUNCH_PURGER_FAIL');

355: l_dev_status,
356: l_message);
357:
358: IF (l_call_status=FALSE) THEN
359: FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_LAUNCH_PURGER_FAIL');
360: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
361:
362: FND_MESSAGE.SET_NAME('MSC', 'MSC_FUNC_MON_RUNNING');
363: FND_MESSAGE.SET_TOKEN('REQUEST_ID',lvs_request_id);

Line 360: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);

356: l_message);
357:
358: IF (l_call_status=FALSE) THEN
359: FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_LAUNCH_PURGER_FAIL');
360: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
361:
362: FND_MESSAGE.SET_NAME('MSC', 'MSC_FUNC_MON_RUNNING');
363: FND_MESSAGE.SET_TOKEN('REQUEST_ID',lvs_request_id);
364: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);

Line 362: FND_MESSAGE.SET_NAME('MSC', 'MSC_FUNC_MON_RUNNING');

358: IF (l_call_status=FALSE) THEN
359: FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_LAUNCH_PURGER_FAIL');
360: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
361:
362: FND_MESSAGE.SET_NAME('MSC', 'MSC_FUNC_MON_RUNNING');
363: FND_MESSAGE.SET_TOKEN('REQUEST_ID',lvs_request_id);
364: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
365:
366: FND_MESSAGE.SET_NAME('MSC', 'MSC_CL_CONC_MESSAGE');

Line 363: FND_MESSAGE.SET_TOKEN('REQUEST_ID',lvs_request_id);

359: FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_LAUNCH_PURGER_FAIL');
360: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
361:
362: FND_MESSAGE.SET_NAME('MSC', 'MSC_FUNC_MON_RUNNING');
363: FND_MESSAGE.SET_TOKEN('REQUEST_ID',lvs_request_id);
364: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
365:
366: FND_MESSAGE.SET_NAME('MSC', 'MSC_CL_CONC_MESSAGE');
367: FND_MESSAGE.SET_TOKEN('MESSAGE',l_message);

Line 364: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);

360: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
361:
362: FND_MESSAGE.SET_NAME('MSC', 'MSC_FUNC_MON_RUNNING');
363: FND_MESSAGE.SET_TOKEN('REQUEST_ID',lvs_request_id);
364: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
365:
366: FND_MESSAGE.SET_NAME('MSC', 'MSC_CL_CONC_MESSAGE');
367: FND_MESSAGE.SET_TOKEN('MESSAGE',l_message);
368: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);

Line 366: FND_MESSAGE.SET_NAME('MSC', 'MSC_CL_CONC_MESSAGE');

362: FND_MESSAGE.SET_NAME('MSC', 'MSC_FUNC_MON_RUNNING');
363: FND_MESSAGE.SET_TOKEN('REQUEST_ID',lvs_request_id);
364: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
365:
366: FND_MESSAGE.SET_NAME('MSC', 'MSC_CL_CONC_MESSAGE');
367: FND_MESSAGE.SET_TOKEN('MESSAGE',l_message);
368: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
369:
370: RETURN FALSE;

Line 367: FND_MESSAGE.SET_TOKEN('MESSAGE',l_message);

363: FND_MESSAGE.SET_TOKEN('REQUEST_ID',lvs_request_id);
364: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
365:
366: FND_MESSAGE.SET_NAME('MSC', 'MSC_CL_CONC_MESSAGE');
367: FND_MESSAGE.SET_TOKEN('MESSAGE',l_message);
368: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
369:
370: RETURN FALSE;
371: END IF;

Line 368: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);

364: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
365:
366: FND_MESSAGE.SET_NAME('MSC', 'MSC_CL_CONC_MESSAGE');
367: FND_MESSAGE.SET_TOKEN('MESSAGE',l_message);
368: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
369:
370: RETURN FALSE;
371: END IF;
372:

Line 381: FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_LAUNCH_PURGER_FAIL');

377: RETURN TRUE;
378:
379: EXCEPTION
380: WHEN OTHERS THEN
381: FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_LAUNCH_PURGER_FAIL');
382: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
383: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, SQLERRM);
384: RETURN FALSE;
385: END PURGE_STAGING;

Line 382: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);

378:
379: EXCEPTION
380: WHEN OTHERS THEN
381: FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_LAUNCH_PURGER_FAIL');
382: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
383: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, SQLERRM);
384: RETURN FALSE;
385: END PURGE_STAGING;
386:

Line 516: FND_MESSAGE.SET_NAME('MSC', 'MSC_FUNC_MON_RUNNING');

512:
513: IF l_call_status=FALSE THEN
514: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, 'IS_MONITOR_STATUS_RUNNING');
515:
516: FND_MESSAGE.SET_NAME('MSC', 'MSC_FUNC_MON_RUNNING');
517: FND_MESSAGE.SET_TOKEN('REQUEST_ID',v_monitor_request_id);
518: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
519:
520: FND_MESSAGE.SET_NAME('MSC', 'MSC_CL_CONC_MESSAGE');

Line 517: FND_MESSAGE.SET_TOKEN('REQUEST_ID',v_monitor_request_id);

513: IF l_call_status=FALSE THEN
514: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, 'IS_MONITOR_STATUS_RUNNING');
515:
516: FND_MESSAGE.SET_NAME('MSC', 'MSC_FUNC_MON_RUNNING');
517: FND_MESSAGE.SET_TOKEN('REQUEST_ID',v_monitor_request_id);
518: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
519:
520: FND_MESSAGE.SET_NAME('MSC', 'MSC_CL_CONC_MESSAGE');
521: FND_MESSAGE.SET_TOKEN('MESSAGE',l_message);

Line 518: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);

514: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, 'IS_MONITOR_STATUS_RUNNING');
515:
516: FND_MESSAGE.SET_NAME('MSC', 'MSC_FUNC_MON_RUNNING');
517: FND_MESSAGE.SET_TOKEN('REQUEST_ID',v_monitor_request_id);
518: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
519:
520: FND_MESSAGE.SET_NAME('MSC', 'MSC_CL_CONC_MESSAGE');
521: FND_MESSAGE.SET_TOKEN('MESSAGE',l_message);
522: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);

Line 520: FND_MESSAGE.SET_NAME('MSC', 'MSC_CL_CONC_MESSAGE');

516: FND_MESSAGE.SET_NAME('MSC', 'MSC_FUNC_MON_RUNNING');
517: FND_MESSAGE.SET_TOKEN('REQUEST_ID',v_monitor_request_id);
518: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
519:
520: FND_MESSAGE.SET_NAME('MSC', 'MSC_CL_CONC_MESSAGE');
521: FND_MESSAGE.SET_TOKEN('MESSAGE',l_message);
522: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
523:
524: RETURN MSC_UTIL.SYS_NO;

Line 521: FND_MESSAGE.SET_TOKEN('MESSAGE',l_message);

517: FND_MESSAGE.SET_TOKEN('REQUEST_ID',v_monitor_request_id);
518: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
519:
520: FND_MESSAGE.SET_NAME('MSC', 'MSC_CL_CONC_MESSAGE');
521: FND_MESSAGE.SET_TOKEN('MESSAGE',l_message);
522: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
523:
524: RETURN MSC_UTIL.SYS_NO;
525: END IF;

Line 522: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);

518: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
519:
520: FND_MESSAGE.SET_NAME('MSC', 'MSC_CL_CONC_MESSAGE');
521: FND_MESSAGE.SET_TOKEN('MESSAGE',l_message);
522: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
523:
524: RETURN MSC_UTIL.SYS_NO;
525: END IF;
526:

Line 532: FND_MESSAGE.SET_NAME('MSC', 'MSC_FUNC_MON_RUN');

528: RETURN MSC_UTIL.SYS_YES;
529: ELSE
530: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, 'IS_MONITOR_STATUS_RUNNING');
531:
532: FND_MESSAGE.SET_NAME('MSC', 'MSC_FUNC_MON_RUN');
533: FND_MESSAGE.SET_TOKEN('REQUEST_ID', v_monitor_request_id);
534: FND_MESSAGE.SET_TOKEN('PHASE',l_dev_phase);
535: FND_MESSAGE.SET_TOKEN('STATUS',l_dev_status);
536: --MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

Line 533: FND_MESSAGE.SET_TOKEN('REQUEST_ID', v_monitor_request_id);

529: ELSE
530: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, 'IS_MONITOR_STATUS_RUNNING');
531:
532: FND_MESSAGE.SET_NAME('MSC', 'MSC_FUNC_MON_RUN');
533: FND_MESSAGE.SET_TOKEN('REQUEST_ID', v_monitor_request_id);
534: FND_MESSAGE.SET_TOKEN('PHASE',l_dev_phase);
535: FND_MESSAGE.SET_TOKEN('STATUS',l_dev_status);
536: --MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
537:

Line 534: FND_MESSAGE.SET_TOKEN('PHASE',l_dev_phase);

530: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, 'IS_MONITOR_STATUS_RUNNING');
531:
532: FND_MESSAGE.SET_NAME('MSC', 'MSC_FUNC_MON_RUN');
533: FND_MESSAGE.SET_TOKEN('REQUEST_ID', v_monitor_request_id);
534: FND_MESSAGE.SET_TOKEN('PHASE',l_dev_phase);
535: FND_MESSAGE.SET_TOKEN('STATUS',l_dev_status);
536: --MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
537:
538: FND_MESSAGE.SET_NAME('MSC', 'MSC_CL_CONC_MESSAGE');

Line 535: FND_MESSAGE.SET_TOKEN('STATUS',l_dev_status);

531:
532: FND_MESSAGE.SET_NAME('MSC', 'MSC_FUNC_MON_RUN');
533: FND_MESSAGE.SET_TOKEN('REQUEST_ID', v_monitor_request_id);
534: FND_MESSAGE.SET_TOKEN('PHASE',l_dev_phase);
535: FND_MESSAGE.SET_TOKEN('STATUS',l_dev_status);
536: --MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
537:
538: FND_MESSAGE.SET_NAME('MSC', 'MSC_CL_CONC_MESSAGE');
539: FND_MESSAGE.SET_TOKEN('MESSAGE',l_message);

Line 536: --MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

532: FND_MESSAGE.SET_NAME('MSC', 'MSC_FUNC_MON_RUN');
533: FND_MESSAGE.SET_TOKEN('REQUEST_ID', v_monitor_request_id);
534: FND_MESSAGE.SET_TOKEN('PHASE',l_dev_phase);
535: FND_MESSAGE.SET_TOKEN('STATUS',l_dev_status);
536: --MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
537:
538: FND_MESSAGE.SET_NAME('MSC', 'MSC_CL_CONC_MESSAGE');
539: FND_MESSAGE.SET_TOKEN('MESSAGE',l_message);
540: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

Line 538: FND_MESSAGE.SET_NAME('MSC', 'MSC_CL_CONC_MESSAGE');

534: FND_MESSAGE.SET_TOKEN('PHASE',l_dev_phase);
535: FND_MESSAGE.SET_TOKEN('STATUS',l_dev_status);
536: --MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
537:
538: FND_MESSAGE.SET_NAME('MSC', 'MSC_CL_CONC_MESSAGE');
539: FND_MESSAGE.SET_TOKEN('MESSAGE',l_message);
540: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
541:
542: RETURN MSC_UTIL.SYS_NO;

Line 539: FND_MESSAGE.SET_TOKEN('MESSAGE',l_message);

535: FND_MESSAGE.SET_TOKEN('STATUS',l_dev_status);
536: --MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
537:
538: FND_MESSAGE.SET_NAME('MSC', 'MSC_CL_CONC_MESSAGE');
539: FND_MESSAGE.SET_TOKEN('MESSAGE',l_message);
540: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
541:
542: RETURN MSC_UTIL.SYS_NO;
543: END IF;

Line 540: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

536: --MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
537:
538: FND_MESSAGE.SET_NAME('MSC', 'MSC_CL_CONC_MESSAGE');
539: FND_MESSAGE.SET_TOKEN('MESSAGE',l_message);
540: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
541:
542: RETURN MSC_UTIL.SYS_NO;
543: END IF;
544:

Line 579: FND_MESSAGE.SET_NAME('MSC', 'MSC_FUNC_MON_RUNNING');

575:
576: IF l_call_status=FALSE THEN
577: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, 'IS_REQUEST_STATUS_RUNNING');
578:
579: FND_MESSAGE.SET_NAME('MSC', 'MSC_FUNC_MON_RUNNING');
580: FND_MESSAGE.SET_TOKEN('REQUEST_ID',l_request_id);
581: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
582:
583: FND_MESSAGE.SET_NAME('MSC', 'MSC_CL_CONC_MESSAGE');

Line 580: FND_MESSAGE.SET_TOKEN('REQUEST_ID',l_request_id);

576: IF l_call_status=FALSE THEN
577: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, 'IS_REQUEST_STATUS_RUNNING');
578:
579: FND_MESSAGE.SET_NAME('MSC', 'MSC_FUNC_MON_RUNNING');
580: FND_MESSAGE.SET_TOKEN('REQUEST_ID',l_request_id);
581: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
582:
583: FND_MESSAGE.SET_NAME('MSC', 'MSC_CL_CONC_MESSAGE');
584: FND_MESSAGE.SET_TOKEN('MESSAGE',l_message);

Line 581: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);

577: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, 'IS_REQUEST_STATUS_RUNNING');
578:
579: FND_MESSAGE.SET_NAME('MSC', 'MSC_FUNC_MON_RUNNING');
580: FND_MESSAGE.SET_TOKEN('REQUEST_ID',l_request_id);
581: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
582:
583: FND_MESSAGE.SET_NAME('MSC', 'MSC_CL_CONC_MESSAGE');
584: FND_MESSAGE.SET_TOKEN('MESSAGE',l_message);
585: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);

Line 583: FND_MESSAGE.SET_NAME('MSC', 'MSC_CL_CONC_MESSAGE');

579: FND_MESSAGE.SET_NAME('MSC', 'MSC_FUNC_MON_RUNNING');
580: FND_MESSAGE.SET_TOKEN('REQUEST_ID',l_request_id);
581: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
582:
583: FND_MESSAGE.SET_NAME('MSC', 'MSC_CL_CONC_MESSAGE');
584: FND_MESSAGE.SET_TOKEN('MESSAGE',l_message);
585: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
586:
587: RETURN MSC_UTIL.SYS_NO;

Line 584: FND_MESSAGE.SET_TOKEN('MESSAGE',l_message);

580: FND_MESSAGE.SET_TOKEN('REQUEST_ID',l_request_id);
581: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
582:
583: FND_MESSAGE.SET_NAME('MSC', 'MSC_CL_CONC_MESSAGE');
584: FND_MESSAGE.SET_TOKEN('MESSAGE',l_message);
585: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
586:
587: RETURN MSC_UTIL.SYS_NO;
588: END IF;

Line 585: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);

581: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
582:
583: FND_MESSAGE.SET_NAME('MSC', 'MSC_CL_CONC_MESSAGE');
584: FND_MESSAGE.SET_TOKEN('MESSAGE',l_message);
585: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
586:
587: RETURN MSC_UTIL.SYS_NO;
588: END IF;
589:

Line 595: FND_MESSAGE.SET_NAME('MSC', 'MSC_FUNC_MON_RUN');

591: RETURN MSC_UTIL.SYS_YES;
592: ELSE
593: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, 'IS_REQUEST_STATUS_RUNNING');
594:
595: FND_MESSAGE.SET_NAME('MSC', 'MSC_FUNC_MON_RUN');
596: FND_MESSAGE.SET_TOKEN('REQUEST_ID',l_request_id);
597: FND_MESSAGE.SET_TOKEN('PHASE',l_dev_phase);
598: FND_MESSAGE.SET_TOKEN('STATUS',l_dev_status);
599: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

Line 596: FND_MESSAGE.SET_TOKEN('REQUEST_ID',l_request_id);

592: ELSE
593: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, 'IS_REQUEST_STATUS_RUNNING');
594:
595: FND_MESSAGE.SET_NAME('MSC', 'MSC_FUNC_MON_RUN');
596: FND_MESSAGE.SET_TOKEN('REQUEST_ID',l_request_id);
597: FND_MESSAGE.SET_TOKEN('PHASE',l_dev_phase);
598: FND_MESSAGE.SET_TOKEN('STATUS',l_dev_status);
599: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
600:

Line 597: FND_MESSAGE.SET_TOKEN('PHASE',l_dev_phase);

593: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, 'IS_REQUEST_STATUS_RUNNING');
594:
595: FND_MESSAGE.SET_NAME('MSC', 'MSC_FUNC_MON_RUN');
596: FND_MESSAGE.SET_TOKEN('REQUEST_ID',l_request_id);
597: FND_MESSAGE.SET_TOKEN('PHASE',l_dev_phase);
598: FND_MESSAGE.SET_TOKEN('STATUS',l_dev_status);
599: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
600:
601: FND_MESSAGE.SET_NAME('MSC', 'MSC_CL_CONC_MESSAGE');

Line 598: FND_MESSAGE.SET_TOKEN('STATUS',l_dev_status);

594:
595: FND_MESSAGE.SET_NAME('MSC', 'MSC_FUNC_MON_RUN');
596: FND_MESSAGE.SET_TOKEN('REQUEST_ID',l_request_id);
597: FND_MESSAGE.SET_TOKEN('PHASE',l_dev_phase);
598: FND_MESSAGE.SET_TOKEN('STATUS',l_dev_status);
599: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
600:
601: FND_MESSAGE.SET_NAME('MSC', 'MSC_CL_CONC_MESSAGE');
602: FND_MESSAGE.SET_TOKEN('MESSAGE',l_message);

Line 599: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

595: FND_MESSAGE.SET_NAME('MSC', 'MSC_FUNC_MON_RUN');
596: FND_MESSAGE.SET_TOKEN('REQUEST_ID',l_request_id);
597: FND_MESSAGE.SET_TOKEN('PHASE',l_dev_phase);
598: FND_MESSAGE.SET_TOKEN('STATUS',l_dev_status);
599: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
600:
601: FND_MESSAGE.SET_NAME('MSC', 'MSC_CL_CONC_MESSAGE');
602: FND_MESSAGE.SET_TOKEN('MESSAGE',l_message);
603: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

Line 601: FND_MESSAGE.SET_NAME('MSC', 'MSC_CL_CONC_MESSAGE');

597: FND_MESSAGE.SET_TOKEN('PHASE',l_dev_phase);
598: FND_MESSAGE.SET_TOKEN('STATUS',l_dev_status);
599: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
600:
601: FND_MESSAGE.SET_NAME('MSC', 'MSC_CL_CONC_MESSAGE');
602: FND_MESSAGE.SET_TOKEN('MESSAGE',l_message);
603: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
604:
605: RETURN MSC_UTIL.SYS_NO;

Line 602: FND_MESSAGE.SET_TOKEN('MESSAGE',l_message);

598: FND_MESSAGE.SET_TOKEN('STATUS',l_dev_status);
599: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
600:
601: FND_MESSAGE.SET_NAME('MSC', 'MSC_CL_CONC_MESSAGE');
602: FND_MESSAGE.SET_TOKEN('MESSAGE',l_message);
603: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
604:
605: RETURN MSC_UTIL.SYS_NO;
606: END IF;

Line 603: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

599: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
600:
601: FND_MESSAGE.SET_NAME('MSC', 'MSC_CL_CONC_MESSAGE');
602: FND_MESSAGE.SET_TOKEN('MESSAGE',l_message);
603: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
604:
605: RETURN MSC_UTIL.SYS_NO;
606: END IF;
607:

Line 644: FND_MESSAGE.SET_NAME('MSC', 'MSC_FUNC_MON_RUNNING');

640:
641: IF l_call_status=FALSE THEN
642: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, 'IS_WORKER_STATUS_VALID');
643:
644: FND_MESSAGE.SET_NAME('MSC', 'MSC_FUNC_MON_RUNNING');
645: FND_MESSAGE.SET_TOKEN('REQUEST_ID',l_request_id);
646: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
647:
648: FND_MESSAGE.SET_NAME('MSC', 'MSC_CL_CONC_MESSAGE');

Line 645: FND_MESSAGE.SET_TOKEN('REQUEST_ID',l_request_id);

641: IF l_call_status=FALSE THEN
642: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, 'IS_WORKER_STATUS_VALID');
643:
644: FND_MESSAGE.SET_NAME('MSC', 'MSC_FUNC_MON_RUNNING');
645: FND_MESSAGE.SET_TOKEN('REQUEST_ID',l_request_id);
646: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
647:
648: FND_MESSAGE.SET_NAME('MSC', 'MSC_CL_CONC_MESSAGE');
649: FND_MESSAGE.SET_TOKEN('MESSAGE',l_message);

Line 646: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);

642: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, 'IS_WORKER_STATUS_VALID');
643:
644: FND_MESSAGE.SET_NAME('MSC', 'MSC_FUNC_MON_RUNNING');
645: FND_MESSAGE.SET_TOKEN('REQUEST_ID',l_request_id);
646: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
647:
648: FND_MESSAGE.SET_NAME('MSC', 'MSC_CL_CONC_MESSAGE');
649: FND_MESSAGE.SET_TOKEN('MESSAGE',l_message);
650: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);

Line 648: FND_MESSAGE.SET_NAME('MSC', 'MSC_CL_CONC_MESSAGE');

644: FND_MESSAGE.SET_NAME('MSC', 'MSC_FUNC_MON_RUNNING');
645: FND_MESSAGE.SET_TOKEN('REQUEST_ID',l_request_id);
646: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
647:
648: FND_MESSAGE.SET_NAME('MSC', 'MSC_CL_CONC_MESSAGE');
649: FND_MESSAGE.SET_TOKEN('MESSAGE',l_message);
650: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
651:
652: RETURN MSC_UTIL.SYS_NO;

Line 649: FND_MESSAGE.SET_TOKEN('MESSAGE',l_message);

645: FND_MESSAGE.SET_TOKEN('REQUEST_ID',l_request_id);
646: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
647:
648: FND_MESSAGE.SET_NAME('MSC', 'MSC_CL_CONC_MESSAGE');
649: FND_MESSAGE.SET_TOKEN('MESSAGE',l_message);
650: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
651:
652: RETURN MSC_UTIL.SYS_NO;
653: END IF;

Line 650: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);

646: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
647:
648: FND_MESSAGE.SET_NAME('MSC', 'MSC_CL_CONC_MESSAGE');
649: FND_MESSAGE.SET_TOKEN('MESSAGE',l_message);
650: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
651:
652: RETURN MSC_UTIL.SYS_NO;
653: END IF;
654:

Line 658: FND_MESSAGE.SET_NAME('MSC', 'MSC_FUNC_MON_RUN');

654:
655: IF l_dev_phase NOT IN ( 'PENDING','RUNNING') THEN
656: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, 'IS_WORKER_STATUS_VALID');
657:
658: FND_MESSAGE.SET_NAME('MSC', 'MSC_FUNC_MON_RUN');
659: FND_MESSAGE.SET_TOKEN('REQUEST_ID',l_request_id);
660: FND_MESSAGE.SET_TOKEN('PHASE',l_dev_phase);
661: FND_MESSAGE.SET_TOKEN('STATUS',l_dev_status);
662: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);

Line 659: FND_MESSAGE.SET_TOKEN('REQUEST_ID',l_request_id);

655: IF l_dev_phase NOT IN ( 'PENDING','RUNNING') THEN
656: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, 'IS_WORKER_STATUS_VALID');
657:
658: FND_MESSAGE.SET_NAME('MSC', 'MSC_FUNC_MON_RUN');
659: FND_MESSAGE.SET_TOKEN('REQUEST_ID',l_request_id);
660: FND_MESSAGE.SET_TOKEN('PHASE',l_dev_phase);
661: FND_MESSAGE.SET_TOKEN('STATUS',l_dev_status);
662: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
663:

Line 660: FND_MESSAGE.SET_TOKEN('PHASE',l_dev_phase);

656: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, 'IS_WORKER_STATUS_VALID');
657:
658: FND_MESSAGE.SET_NAME('MSC', 'MSC_FUNC_MON_RUN');
659: FND_MESSAGE.SET_TOKEN('REQUEST_ID',l_request_id);
660: FND_MESSAGE.SET_TOKEN('PHASE',l_dev_phase);
661: FND_MESSAGE.SET_TOKEN('STATUS',l_dev_status);
662: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
663:
664: FND_MESSAGE.SET_NAME('MSC', 'MSC_CL_CONC_MESSAGE');

Line 661: FND_MESSAGE.SET_TOKEN('STATUS',l_dev_status);

657:
658: FND_MESSAGE.SET_NAME('MSC', 'MSC_FUNC_MON_RUN');
659: FND_MESSAGE.SET_TOKEN('REQUEST_ID',l_request_id);
660: FND_MESSAGE.SET_TOKEN('PHASE',l_dev_phase);
661: FND_MESSAGE.SET_TOKEN('STATUS',l_dev_status);
662: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
663:
664: FND_MESSAGE.SET_NAME('MSC', 'MSC_CL_CONC_MESSAGE');
665: FND_MESSAGE.SET_TOKEN('MESSAGE',l_message);

Line 662: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);

658: FND_MESSAGE.SET_NAME('MSC', 'MSC_FUNC_MON_RUN');
659: FND_MESSAGE.SET_TOKEN('REQUEST_ID',l_request_id);
660: FND_MESSAGE.SET_TOKEN('PHASE',l_dev_phase);
661: FND_MESSAGE.SET_TOKEN('STATUS',l_dev_status);
662: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
663:
664: FND_MESSAGE.SET_NAME('MSC', 'MSC_CL_CONC_MESSAGE');
665: FND_MESSAGE.SET_TOKEN('MESSAGE',l_message);
666: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);

Line 664: FND_MESSAGE.SET_NAME('MSC', 'MSC_CL_CONC_MESSAGE');

660: FND_MESSAGE.SET_TOKEN('PHASE',l_dev_phase);
661: FND_MESSAGE.SET_TOKEN('STATUS',l_dev_status);
662: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
663:
664: FND_MESSAGE.SET_NAME('MSC', 'MSC_CL_CONC_MESSAGE');
665: FND_MESSAGE.SET_TOKEN('MESSAGE',l_message);
666: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
667:
668: RETURN MSC_UTIL.SYS_NO;

Line 665: FND_MESSAGE.SET_TOKEN('MESSAGE',l_message);

661: FND_MESSAGE.SET_TOKEN('STATUS',l_dev_status);
662: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
663:
664: FND_MESSAGE.SET_NAME('MSC', 'MSC_CL_CONC_MESSAGE');
665: FND_MESSAGE.SET_TOKEN('MESSAGE',l_message);
666: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
667:
668: RETURN MSC_UTIL.SYS_NO;
669: END IF;

Line 666: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);

662: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
663:
664: FND_MESSAGE.SET_NAME('MSC', 'MSC_CL_CONC_MESSAGE');
665: FND_MESSAGE.SET_TOKEN('MESSAGE',l_message);
666: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
667:
668: RETURN MSC_UTIL.SYS_NO;
669: END IF;
670:

Line 723: FND_MESSAGE.SET_NAME('MSC', 'MSC_FUNC_MON_RUN');

719: req_complete := req_complete + 1;
720:
721: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'ALL_WORKERS_COMPLETED');
722:
723: FND_MESSAGE.SET_NAME('MSC', 'MSC_FUNC_MON_RUN');
724: FND_MESSAGE.SET_TOKEN('REQUEST_ID',l_request_id);
725: FND_MESSAGE.SET_TOKEN('PHASE',l_dev_phase);
726: FND_MESSAGE.SET_TOKEN('STATUS',l_dev_status);
727: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, FND_MESSAGE.GET);

Line 724: FND_MESSAGE.SET_TOKEN('REQUEST_ID',l_request_id);

720:
721: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'ALL_WORKERS_COMPLETED');
722:
723: FND_MESSAGE.SET_NAME('MSC', 'MSC_FUNC_MON_RUN');
724: FND_MESSAGE.SET_TOKEN('REQUEST_ID',l_request_id);
725: FND_MESSAGE.SET_TOKEN('PHASE',l_dev_phase);
726: FND_MESSAGE.SET_TOKEN('STATUS',l_dev_status);
727: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, FND_MESSAGE.GET);
728:

Line 725: FND_MESSAGE.SET_TOKEN('PHASE',l_dev_phase);

721: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'ALL_WORKERS_COMPLETED');
722:
723: FND_MESSAGE.SET_NAME('MSC', 'MSC_FUNC_MON_RUN');
724: FND_MESSAGE.SET_TOKEN('REQUEST_ID',l_request_id);
725: FND_MESSAGE.SET_TOKEN('PHASE',l_dev_phase);
726: FND_MESSAGE.SET_TOKEN('STATUS',l_dev_status);
727: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, FND_MESSAGE.GET);
728:
729: FND_MESSAGE.SET_NAME('MSC', 'MSC_CL_TOTAL_REQS_COMPLETE');

Line 726: FND_MESSAGE.SET_TOKEN('STATUS',l_dev_status);

722:
723: FND_MESSAGE.SET_NAME('MSC', 'MSC_FUNC_MON_RUN');
724: FND_MESSAGE.SET_TOKEN('REQUEST_ID',l_request_id);
725: FND_MESSAGE.SET_TOKEN('PHASE',l_dev_phase);
726: FND_MESSAGE.SET_TOKEN('STATUS',l_dev_status);
727: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, FND_MESSAGE.GET);
728:
729: FND_MESSAGE.SET_NAME('MSC', 'MSC_CL_TOTAL_REQS_COMPLETE');
730: FND_MESSAGE.SET_TOKEN('REQUESTS',req_complete);

Line 727: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, FND_MESSAGE.GET);

723: FND_MESSAGE.SET_NAME('MSC', 'MSC_FUNC_MON_RUN');
724: FND_MESSAGE.SET_TOKEN('REQUEST_ID',l_request_id);
725: FND_MESSAGE.SET_TOKEN('PHASE',l_dev_phase);
726: FND_MESSAGE.SET_TOKEN('STATUS',l_dev_status);
727: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, FND_MESSAGE.GET);
728:
729: FND_MESSAGE.SET_NAME('MSC', 'MSC_CL_TOTAL_REQS_COMPLETE');
730: FND_MESSAGE.SET_TOKEN('REQUESTS',req_complete);
731: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, FND_MESSAGE.GET);

Line 729: FND_MESSAGE.SET_NAME('MSC', 'MSC_CL_TOTAL_REQS_COMPLETE');

725: FND_MESSAGE.SET_TOKEN('PHASE',l_dev_phase);
726: FND_MESSAGE.SET_TOKEN('STATUS',l_dev_status);
727: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, FND_MESSAGE.GET);
728:
729: FND_MESSAGE.SET_NAME('MSC', 'MSC_CL_TOTAL_REQS_COMPLETE');
730: FND_MESSAGE.SET_TOKEN('REQUESTS',req_complete);
731: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, FND_MESSAGE.GET);
732:
733: END IF;

Line 730: FND_MESSAGE.SET_TOKEN('REQUESTS',req_complete);

726: FND_MESSAGE.SET_TOKEN('STATUS',l_dev_status);
727: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, FND_MESSAGE.GET);
728:
729: FND_MESSAGE.SET_NAME('MSC', 'MSC_CL_TOTAL_REQS_COMPLETE');
730: FND_MESSAGE.SET_TOKEN('REQUESTS',req_complete);
731: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, FND_MESSAGE.GET);
732:
733: END IF;
734:

Line 731: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, FND_MESSAGE.GET);

727: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, FND_MESSAGE.GET);
728:
729: FND_MESSAGE.SET_NAME('MSC', 'MSC_CL_TOTAL_REQS_COMPLETE');
730: FND_MESSAGE.SET_TOKEN('REQUESTS',req_complete);
731: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, FND_MESSAGE.GET);
732:
733: END IF;
734:
735: END LOOP;

Line 738: FND_MESSAGE.SET_NAME('MSC', 'MSC_CL_ALL_WORKERS_COMP');

734:
735: END LOOP;
736:
737: IF total_req = req_complete THEN
738: FND_MESSAGE.SET_NAME('MSC', 'MSC_CL_ALL_WORKERS_COMP');
739: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
740: RETURN MSC_UTIL.SYS_YES;
741: ELSE
742: RETURN MSC_UTIL.SYS_NO;

Line 739: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

735: END LOOP;
736:
737: IF total_req = req_complete THEN
738: FND_MESSAGE.SET_NAME('MSC', 'MSC_CL_ALL_WORKERS_COMP');
739: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
740: RETURN MSC_UTIL.SYS_YES;
741: ELSE
742: RETURN MSC_UTIL.SYS_NO;
743: END IF;

Line 804: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');

800:
801: lv_retval := FND_INSTALLATION.GET_APP_INFO (
802: 'MSC', lv_dummy1, lv_dummy2, lv_msc_schema);
803:
804: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
805: FND_MESSAGE.SET_TOKEN('PROCEDURE',
806: 'TRUNCATE_MSC_TABLE:'||lv_msc_schema||'.'||p_table_name);
807: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, ' '||FND_MESSAGE.GET);
808:

Line 805: FND_MESSAGE.SET_TOKEN('PROCEDURE',

801: lv_retval := FND_INSTALLATION.GET_APP_INFO (
802: 'MSC', lv_dummy1, lv_dummy2, lv_msc_schema);
803:
804: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
805: FND_MESSAGE.SET_TOKEN('PROCEDURE',
806: 'TRUNCATE_MSC_TABLE:'||lv_msc_schema||'.'||p_table_name);
807: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, ' '||FND_MESSAGE.GET);
808:
809: lv_sql_stmt:= 'TRUNCATE TABLE '||lv_msc_schema||'.'||p_table_name;

Line 807: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, ' '||FND_MESSAGE.GET);

803:
804: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
805: FND_MESSAGE.SET_TOKEN('PROCEDURE',
806: 'TRUNCATE_MSC_TABLE:'||lv_msc_schema||'.'||p_table_name);
807: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, ' '||FND_MESSAGE.GET);
808:
809: lv_sql_stmt:= 'TRUNCATE TABLE '||lv_msc_schema||'.'||p_table_name;
810:
811: EXECUTE IMMEDIATE lv_sql_stmt;

Line 823: FND_MESSAGE.SET_NAME('MSC', 'MSC_ELAPSED_TIME');

819: OBJECT_NAME => p_table_name);
820: */
821:
822:
823: FND_MESSAGE.SET_NAME('MSC', 'MSC_ELAPSED_TIME');
824: FND_MESSAGE.SET_TOKEN('ELAPSED_TIME',
825: TO_CHAR(CEIL((SYSDATE- lv_task_start_time)*14400.0)/10));
826: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, ' '||FND_MESSAGE.GET);
827:

Line 824: FND_MESSAGE.SET_TOKEN('ELAPSED_TIME',

820: */
821:
822:
823: FND_MESSAGE.SET_NAME('MSC', 'MSC_ELAPSED_TIME');
824: FND_MESSAGE.SET_TOKEN('ELAPSED_TIME',
825: TO_CHAR(CEIL((SYSDATE- lv_task_start_time)*14400.0)/10));
826: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, ' '||FND_MESSAGE.GET);
827:
828: msc_util.print_top_wait(CEIL((SYSDATE- lv_task_start_time)*14400.0)/10);

Line 826: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, ' '||FND_MESSAGE.GET);

822:
823: FND_MESSAGE.SET_NAME('MSC', 'MSC_ELAPSED_TIME');
824: FND_MESSAGE.SET_TOKEN('ELAPSED_TIME',
825: TO_CHAR(CEIL((SYSDATE- lv_task_start_time)*14400.0)/10));
826: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, ' '||FND_MESSAGE.GET);
827:
828: msc_util.print_top_wait(CEIL((SYSDATE- lv_task_start_time)*14400.0)/10);
829: msc_util.print_cum_stat(CEIL((SYSDATE- lv_task_start_time)*14400.0)/10);
830: msc_util.print_bad_sqls(CEIL((SYSDATE- lv_task_start_time)*14400.0)/10);

Line 980: FND_MESSAGE.SET_NAME('MSC', 'MSC_ST_ERROR_NO_DATA');

976: FOR UPDATE;
977:
978: IF lv_staging_table_status= MSC_UTIL.G_ST_EMPTY THEN
979: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS,'lv_staging_table_status = MSC_UTIL.G_ST_EMPTY');
980: FND_MESSAGE.SET_NAME('MSC', 'MSC_ST_ERROR_NO_DATA');
981: ERRBUF:= FND_MESSAGE.GET;
982:
983: RETCODE := MSC_UTIL.G_WARNING;
984: RETURN FALSE;

Line 981: ERRBUF:= FND_MESSAGE.GET;

977:
978: IF lv_staging_table_status= MSC_UTIL.G_ST_EMPTY THEN
979: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS,'lv_staging_table_status = MSC_UTIL.G_ST_EMPTY');
980: FND_MESSAGE.SET_NAME('MSC', 'MSC_ST_ERROR_NO_DATA');
981: ERRBUF:= FND_MESSAGE.GET;
982:
983: RETCODE := MSC_UTIL.G_WARNING;
984: RETURN FALSE;
985:

Line 988: FND_MESSAGE.SET_NAME('MSC', 'MSC_ST_ERROR_PULLING');

984: RETURN FALSE;
985:
986: ELSIF lv_staging_table_status= MSC_UTIL.G_ST_PULLING THEN
987: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS,'lv_staging_table_status = MSC_UTIL.G_ST_PULLING');
988: FND_MESSAGE.SET_NAME('MSC', 'MSC_ST_ERROR_PULLING');
989: ERRBUF:= FND_MESSAGE.GET;
990:
991: RETCODE := MSC_UTIL.G_ERROR;
992: RETURN FALSE;

Line 989: ERRBUF:= FND_MESSAGE.GET;

985:
986: ELSIF lv_staging_table_status= MSC_UTIL.G_ST_PULLING THEN
987: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS,'lv_staging_table_status = MSC_UTIL.G_ST_PULLING');
988: FND_MESSAGE.SET_NAME('MSC', 'MSC_ST_ERROR_PULLING');
989: ERRBUF:= FND_MESSAGE.GET;
990:
991: RETCODE := MSC_UTIL.G_ERROR;
992: RETURN FALSE;
993:

Line 996: FND_MESSAGE.SET_NAME('MSC', 'MSC_ST_ERROR_LOADING');

992: RETURN FALSE;
993:
994: ELSIF lv_staging_table_status= MSC_UTIL.G_ST_COLLECTING THEN
995: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS,'lv_staging_table_status = MSC_UTIL.G_ST_COLLECTING');
996: FND_MESSAGE.SET_NAME('MSC', 'MSC_ST_ERROR_LOADING');
997: ERRBUF:= FND_MESSAGE.GET;
998:
999: RETCODE := MSC_UTIL.G_ERROR;
1000: RETURN FALSE;

Line 997: ERRBUF:= FND_MESSAGE.GET;

993:
994: ELSIF lv_staging_table_status= MSC_UTIL.G_ST_COLLECTING THEN
995: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS,'lv_staging_table_status = MSC_UTIL.G_ST_COLLECTING');
996: FND_MESSAGE.SET_NAME('MSC', 'MSC_ST_ERROR_LOADING');
997: ERRBUF:= FND_MESSAGE.GET;
998:
999: RETCODE := MSC_UTIL.G_ERROR;
1000: RETURN FALSE;
1001:

Line 1004: FND_MESSAGE.SET_NAME('MSC', 'MSC_ST_ERROR_PURGING');

1000: RETURN FALSE;
1001:
1002: ELSIF lv_staging_table_status= MSC_UTIL.G_ST_PURGING THEN
1003: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS,'lv_staging_table_status = MSC_UTIL.G_ST_PURGING');
1004: FND_MESSAGE.SET_NAME('MSC', 'MSC_ST_ERROR_PURGING');
1005: ERRBUF:= FND_MESSAGE.GET;
1006:
1007: RETCODE := MSC_UTIL.G_ERROR;
1008: RETURN FALSE;

Line 1005: ERRBUF:= FND_MESSAGE.GET;

1001:
1002: ELSIF lv_staging_table_status= MSC_UTIL.G_ST_PURGING THEN
1003: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS,'lv_staging_table_status = MSC_UTIL.G_ST_PURGING');
1004: FND_MESSAGE.SET_NAME('MSC', 'MSC_ST_ERROR_PURGING');
1005: ERRBUF:= FND_MESSAGE.GET;
1006:
1007: RETCODE := MSC_UTIL.G_ERROR;
1008: RETURN FALSE;
1009:

Line 1042: FND_MESSAGE.SET_NAME('MSC', 'MSC_ST_ERROR_NO_DATA');

1038: FOR UPDATE;
1039:
1040: IF lv_staging_table_status= MSC_UTIL.G_ST_EMPTY THEN
1041: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS,' lv_staging_table_status= MSC_UTIL.G_ST_EMPTY ');
1042: FND_MESSAGE.SET_NAME('MSC', 'MSC_ST_ERROR_NO_DATA');
1043: ERRBUF:= FND_MESSAGE.GET;
1044:
1045: RETCODE := MSC_UTIL.G_WARNING;
1046: RETURN FALSE;

Line 1043: ERRBUF:= FND_MESSAGE.GET;

1039:
1040: IF lv_staging_table_status= MSC_UTIL.G_ST_EMPTY THEN
1041: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS,' lv_staging_table_status= MSC_UTIL.G_ST_EMPTY ');
1042: FND_MESSAGE.SET_NAME('MSC', 'MSC_ST_ERROR_NO_DATA');
1043: ERRBUF:= FND_MESSAGE.GET;
1044:
1045: RETCODE := MSC_UTIL.G_WARNING;
1046: RETURN FALSE;
1047:

Line 1050: FND_MESSAGE.SET_NAME('MSC', 'MSC_ST_ERROR_PULLING');

1046: RETURN FALSE;
1047:
1048: ELSIF lv_staging_table_status= MSC_UTIL.G_ST_PULLING THEN
1049: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS,' lv_staging_table_status= MSC_UTIL.G_ST_PULLING ');
1050: FND_MESSAGE.SET_NAME('MSC', 'MSC_ST_ERROR_PULLING');
1051: ERRBUF:= FND_MESSAGE.GET;
1052:
1053: RETCODE := MSC_UTIL.G_ERROR;
1054: RETURN FALSE;

Line 1051: ERRBUF:= FND_MESSAGE.GET;

1047:
1048: ELSIF lv_staging_table_status= MSC_UTIL.G_ST_PULLING THEN
1049: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS,' lv_staging_table_status= MSC_UTIL.G_ST_PULLING ');
1050: FND_MESSAGE.SET_NAME('MSC', 'MSC_ST_ERROR_PULLING');
1051: ERRBUF:= FND_MESSAGE.GET;
1052:
1053: RETCODE := MSC_UTIL.G_ERROR;
1054: RETURN FALSE;
1055:

Line 1058: FND_MESSAGE.SET_NAME('MSC', 'MSC_ST_ERROR_DATA_EXIST');

1054: RETURN FALSE;
1055:
1056: ELSIF lv_staging_table_status= MSC_UTIL.G_ST_COLLECTING THEN
1057: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS,' lv_staging_table_status= MSC_UTIL.G_ST_COLLECTING ');
1058: FND_MESSAGE.SET_NAME('MSC', 'MSC_ST_ERROR_DATA_EXIST');
1059: ERRBUF:= FND_MESSAGE.GET;
1060:
1061: RETCODE := MSC_UTIL.G_ERROR;
1062: RETURN FALSE;

Line 1059: ERRBUF:= FND_MESSAGE.GET;

1055:
1056: ELSIF lv_staging_table_status= MSC_UTIL.G_ST_COLLECTING THEN
1057: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS,' lv_staging_table_status= MSC_UTIL.G_ST_COLLECTING ');
1058: FND_MESSAGE.SET_NAME('MSC', 'MSC_ST_ERROR_DATA_EXIST');
1059: ERRBUF:= FND_MESSAGE.GET;
1060:
1061: RETCODE := MSC_UTIL.G_ERROR;
1062: RETURN FALSE;
1063:

Line 1066: FND_MESSAGE.SET_NAME('MSC', 'MSC_ST_ERROR_PURGING');

1062: RETURN FALSE;
1063:
1064: ELSIF lv_staging_table_status= MSC_UTIL.G_ST_PURGING THEN
1065: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS,' lv_staging_table_status= MSC_UTIL.G_ST_PURGING ');
1066: FND_MESSAGE.SET_NAME('MSC', 'MSC_ST_ERROR_PURGING');
1067: ERRBUF:= FND_MESSAGE.GET;
1068:
1069: RETCODE := MSC_UTIL.G_ERROR;
1070: RETURN FALSE;

Line 1067: ERRBUF:= FND_MESSAGE.GET;

1063:
1064: ELSIF lv_staging_table_status= MSC_UTIL.G_ST_PURGING THEN
1065: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS,' lv_staging_table_status= MSC_UTIL.G_ST_PURGING ');
1066: FND_MESSAGE.SET_NAME('MSC', 'MSC_ST_ERROR_PURGING');
1067: ERRBUF:= FND_MESSAGE.GET;
1068:
1069: RETCODE := MSC_UTIL.G_ERROR;
1070: RETURN FALSE;
1071:

Line 1169: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');

1165: BEGIN
1166:
1167: lv_task_start_time:= SYSDATE;
1168:
1169: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1170: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'DELETE_MSC_TABLE:'||p_table_name);
1171: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, ' '||FND_MESSAGE.GET);
1172: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, p_table_name||':'||p_sub_str);
1173: IF p_sub_str IS NULL AND

Line 1170: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'DELETE_MSC_TABLE:'||p_table_name);

1166:
1167: lv_task_start_time:= SYSDATE;
1168:
1169: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1170: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'DELETE_MSC_TABLE:'||p_table_name);
1171: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, ' '||FND_MESSAGE.GET);
1172: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, p_table_name||':'||p_sub_str);
1173: IF p_sub_str IS NULL AND
1174: is_msctbl_partitioned( p_table_name) THEN

Line 1171: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, ' '||FND_MESSAGE.GET);

1167: lv_task_start_time:= SYSDATE;
1168:
1169: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1170: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'DELETE_MSC_TABLE:'||p_table_name);
1171: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, ' '||FND_MESSAGE.GET);
1172: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, p_table_name||':'||p_sub_str);
1173: IF p_sub_str IS NULL AND
1174: is_msctbl_partitioned( p_table_name) THEN
1175: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, 'debug1');

Line 1303: FND_MESSAGE.SET_NAME('MSC', 'MSC_ELAPSED_TIME');

1299: END IF; /* batch_size */
1300: END IF; /* plan_id */
1301: END IF; /* is_msctbl_partitioned */
1302:
1303: FND_MESSAGE.SET_NAME('MSC', 'MSC_ELAPSED_TIME');
1304: FND_MESSAGE.SET_TOKEN('ELAPSED_TIME',
1305: TO_CHAR(CEIL((SYSDATE- lv_task_start_time)*14400.0)/10));
1306: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, ' '||FND_MESSAGE.GET);
1307:

Line 1304: FND_MESSAGE.SET_TOKEN('ELAPSED_TIME',

1300: END IF; /* plan_id */
1301: END IF; /* is_msctbl_partitioned */
1302:
1303: FND_MESSAGE.SET_NAME('MSC', 'MSC_ELAPSED_TIME');
1304: FND_MESSAGE.SET_TOKEN('ELAPSED_TIME',
1305: TO_CHAR(CEIL((SYSDATE- lv_task_start_time)*14400.0)/10));
1306: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, ' '||FND_MESSAGE.GET);
1307:
1308: msc_util.print_top_wait(CEIL((SYSDATE- lv_task_start_time)*14400.0)/10);

Line 1306: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, ' '||FND_MESSAGE.GET);

1302:
1303: FND_MESSAGE.SET_NAME('MSC', 'MSC_ELAPSED_TIME');
1304: FND_MESSAGE.SET_TOKEN('ELAPSED_TIME',
1305: TO_CHAR(CEIL((SYSDATE- lv_task_start_time)*14400.0)/10));
1306: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, ' '||FND_MESSAGE.GET);
1307:
1308: msc_util.print_top_wait(CEIL((SYSDATE- lv_task_start_time)*14400.0)/10);
1309: msc_util.print_cum_stat(CEIL((SYSDATE- lv_task_start_time)*14400.0)/10);
1310: msc_util.print_bad_sqls(CEIL((SYSDATE- lv_task_start_time)*14400.0)/10);

Line 1423: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');

1419: set SUPPLIES_LOAD_FLAG = G_JOB_NOT_DONE
1420: where instance_id = v_instance_id;
1421: commit;
1422:
1423: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1424: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SUPPLY_ODS_LOAD.LOAD_SUPPLY');
1425: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1426: MSC_CL_SUPPLY_ODS_LOAD.LOAD_SUPPLY;
1427:

Line 1424: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SUPPLY_ODS_LOAD.LOAD_SUPPLY');

1420: where instance_id = v_instance_id;
1421: commit;
1422:
1423: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1424: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SUPPLY_ODS_LOAD.LOAD_SUPPLY');
1425: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1426: MSC_CL_SUPPLY_ODS_LOAD.LOAD_SUPPLY;
1427:
1428: IF v_is_complete_refresh AND v_exchange_mode=MSC_UTIL.SYS_NO THEN

Line 1425: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

1421: commit;
1422:
1423: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1424: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SUPPLY_ODS_LOAD.LOAD_SUPPLY');
1425: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1426: MSC_CL_SUPPLY_ODS_LOAD.LOAD_SUPPLY;
1427:
1428: IF v_is_complete_refresh AND v_exchange_mode=MSC_UTIL.SYS_NO THEN
1429: -- DELETE_MSC_TABLE( 'MSC_RESOURCE_REQUIREMENTS', v_instance_id, -1);

Line 1446: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');

1442:
1443: IF ((v_coll_prec.org_group_flag <> MSC_UTIL.G_ALL_ORGANIZATIONS ) AND (v_exchange_mode = MSC_UTIL.SYS_YES)) THEN
1444: --(irrelevant now)For Continious (as in execute_partial_task before calling LOAD_SUPPLY in Continious collections
1445: -- exchange mode is set no) and incremental collections exchange_mode will be NO.The only left case is Complete collections.
1446: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1447: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SUPPLY_ODS_LOAD.LOAD_ODS_SUPPLY');
1448: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1449: MSC_CL_SUPPLY_ODS_LOAD.LOAD_ODS_SUPPLY;
1450:

Line 1447: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SUPPLY_ODS_LOAD.LOAD_ODS_SUPPLY');

1443: IF ((v_coll_prec.org_group_flag <> MSC_UTIL.G_ALL_ORGANIZATIONS ) AND (v_exchange_mode = MSC_UTIL.SYS_YES)) THEN
1444: --(irrelevant now)For Continious (as in execute_partial_task before calling LOAD_SUPPLY in Continious collections
1445: -- exchange mode is set no) and incremental collections exchange_mode will be NO.The only left case is Complete collections.
1446: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1447: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SUPPLY_ODS_LOAD.LOAD_ODS_SUPPLY');
1448: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1449: MSC_CL_SUPPLY_ODS_LOAD.LOAD_ODS_SUPPLY;
1450:
1451: END IF;

Line 1448: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

1444: --(irrelevant now)For Continious (as in execute_partial_task before calling LOAD_SUPPLY in Continious collections
1445: -- exchange mode is set no) and incremental collections exchange_mode will be NO.The only left case is Complete collections.
1446: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1447: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SUPPLY_ODS_LOAD.LOAD_ODS_SUPPLY');
1448: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1449: MSC_CL_SUPPLY_ODS_LOAD.LOAD_ODS_SUPPLY;
1450:
1451: END IF;
1452:

Line 1464: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');

1460:
1461: ELSIF pTASKNUM= TASK_MDS_DEMAND THEN
1462:
1463: IF MSC_CL_SUPPLY_ODS_LOAD.IS_SUPPLIES_LOAD_DONE THEN
1464: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1465: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LOAD_DEMAND');
1466: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1467: MSC_CL_DEMAND_ODS_LOAD.LOAD_DEMAND;
1468: ELSE

Line 1465: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LOAD_DEMAND');

1461: ELSIF pTASKNUM= TASK_MDS_DEMAND THEN
1462:
1463: IF MSC_CL_SUPPLY_ODS_LOAD.IS_SUPPLIES_LOAD_DONE THEN
1464: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1465: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LOAD_DEMAND');
1466: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1467: MSC_CL_DEMAND_ODS_LOAD.LOAD_DEMAND;
1468: ELSE
1469: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, 'Loading of Supplies failed.TASK_MDS_DEMAND');

Line 1466: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

1462:
1463: IF MSC_CL_SUPPLY_ODS_LOAD.IS_SUPPLIES_LOAD_DONE THEN
1464: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1465: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LOAD_DEMAND');
1466: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1467: MSC_CL_DEMAND_ODS_LOAD.LOAD_DEMAND;
1468: ELSE
1469: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, 'Loading of Supplies failed.TASK_MDS_DEMAND');
1470: RAISE SUPPLIES_LOAD_FAIL;

Line 1475: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');

1471: END IF;
1472:
1473: ELSIF pTASKNUM= TASK_ITEM_FORECASTS THEN
1474:
1475: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1476: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LOAD_ITEM_FORECASTS');
1477: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1478: MSC_CL_DEMAND_ODS_LOAD.LOAD_ITEM_FORECASTS;
1479:

Line 1476: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LOAD_ITEM_FORECASTS');

1472:
1473: ELSIF pTASKNUM= TASK_ITEM_FORECASTS THEN
1474:
1475: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1476: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LOAD_ITEM_FORECASTS');
1477: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1478: MSC_CL_DEMAND_ODS_LOAD.LOAD_ITEM_FORECASTS;
1479:
1480: ELSIF pTASKNUM= TASK_WIP_COMP_DEMAND THEN

Line 1477: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

1473: ELSIF pTASKNUM= TASK_ITEM_FORECASTS THEN
1474:
1475: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1476: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LOAD_ITEM_FORECASTS');
1477: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1478: MSC_CL_DEMAND_ODS_LOAD.LOAD_ITEM_FORECASTS;
1479:
1480: ELSIF pTASKNUM= TASK_WIP_COMP_DEMAND THEN
1481:

Line 1483: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');

1479:
1480: ELSIF pTASKNUM= TASK_WIP_COMP_DEMAND THEN
1481:
1482: IF MSC_CL_SUPPLY_ODS_LOAD.IS_SUPPLIES_LOAD_DONE THEN
1483: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1484: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_WIP_ODS_LOAD.LOAD_WIP_DEMAND');
1485: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1486: MSC_CL_WIP_ODS_LOAD.LOAD_WIP_DEMAND;
1487: ELSE

Line 1484: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_WIP_ODS_LOAD.LOAD_WIP_DEMAND');

1480: ELSIF pTASKNUM= TASK_WIP_COMP_DEMAND THEN
1481:
1482: IF MSC_CL_SUPPLY_ODS_LOAD.IS_SUPPLIES_LOAD_DONE THEN
1483: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1484: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_WIP_ODS_LOAD.LOAD_WIP_DEMAND');
1485: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1486: MSC_CL_WIP_ODS_LOAD.LOAD_WIP_DEMAND;
1487: ELSE
1488: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, 'Loading of Supplies failed.TASK_WIP_COMP_DEMAND');

Line 1485: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

1481:
1482: IF MSC_CL_SUPPLY_ODS_LOAD.IS_SUPPLIES_LOAD_DONE THEN
1483: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1484: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_WIP_ODS_LOAD.LOAD_WIP_DEMAND');
1485: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1486: MSC_CL_WIP_ODS_LOAD.LOAD_WIP_DEMAND;
1487: ELSE
1488: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, 'Loading of Supplies failed.TASK_WIP_COMP_DEMAND');
1489: RAISE SUPPLIES_LOAD_FAIL;

Line 1496: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');

1492: ELSIF pTASKNUM= TASK_ODS_DEMAND THEN
1493:
1494: IF ((v_coll_prec.org_group_flag <> MSC_UTIL.G_ALL_ORGANIZATIONS ) AND (v_exchange_mode = MSC_UTIL.SYS_YES)) THEN
1495:
1496: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1497: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LOAD_ODS_DEMAND');
1498: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1499: MSC_CL_DEMAND_ODS_LOAD.LOAD_ODS_DEMAND;
1500: ELSE

Line 1497: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LOAD_ODS_DEMAND');

1493:
1494: IF ((v_coll_prec.org_group_flag <> MSC_UTIL.G_ALL_ORGANIZATIONS ) AND (v_exchange_mode = MSC_UTIL.SYS_YES)) THEN
1495:
1496: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1497: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LOAD_ODS_DEMAND');
1498: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1499: MSC_CL_DEMAND_ODS_LOAD.LOAD_ODS_DEMAND;
1500: ELSE
1501: NULL;

Line 1498: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

1494: IF ((v_coll_prec.org_group_flag <> MSC_UTIL.G_ALL_ORGANIZATIONS ) AND (v_exchange_mode = MSC_UTIL.SYS_YES)) THEN
1495:
1496: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1497: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LOAD_ODS_DEMAND');
1498: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1499: MSC_CL_DEMAND_ODS_LOAD.LOAD_ODS_DEMAND;
1500: ELSE
1501: NULL;
1502: END IF;

Line 1507: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');

1503:
1504: ELSIF pTASKNUM= TASK_RES_REQ THEN
1505:
1506: IF MSC_CL_SUPPLY_ODS_LOAD.IS_SUPPLIES_LOAD_DONE THEN
1507: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1508: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_WIP_ODS_LOAD.LOAD_RES_REQ');
1509: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1510: MSC_CL_WIP_ODS_LOAD.LOAD_RES_REQ;
1511: ELSE

Line 1508: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_WIP_ODS_LOAD.LOAD_RES_REQ');

1504: ELSIF pTASKNUM= TASK_RES_REQ THEN
1505:
1506: IF MSC_CL_SUPPLY_ODS_LOAD.IS_SUPPLIES_LOAD_DONE THEN
1507: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1508: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_WIP_ODS_LOAD.LOAD_RES_REQ');
1509: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1510: MSC_CL_WIP_ODS_LOAD.LOAD_RES_REQ;
1511: ELSE
1512: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, 'Loading of Supplies failed. TASK_RES_REQ');

Line 1509: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

1505:
1506: IF MSC_CL_SUPPLY_ODS_LOAD.IS_SUPPLIES_LOAD_DONE THEN
1507: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1508: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_WIP_ODS_LOAD.LOAD_RES_REQ');
1509: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1510: MSC_CL_WIP_ODS_LOAD.LOAD_RES_REQ;
1511: ELSE
1512: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, 'Loading of Supplies failed. TASK_RES_REQ');
1513: RAISE SUPPLIES_LOAD_FAIL;

Line 1518: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');

1514: END IF;
1515:
1516: ELSIF pTASKNUM= TASK_BOR THEN
1517:
1518: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1519: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_BOM_ODS_LOAD.LOAD_BOR');
1520: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1521: MSC_CL_BOM_ODS_LOAD.LOAD_BOR;
1522:

Line 1519: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_BOM_ODS_LOAD.LOAD_BOR');

1515:
1516: ELSIF pTASKNUM= TASK_BOR THEN
1517:
1518: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1519: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_BOM_ODS_LOAD.LOAD_BOR');
1520: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1521: MSC_CL_BOM_ODS_LOAD.LOAD_BOR;
1522:
1523: ELSIF pTASKNUM= TASK_CALENDAR_DATE THEN

Line 1520: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

1516: ELSIF pTASKNUM= TASK_BOR THEN
1517:
1518: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1519: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_BOM_ODS_LOAD.LOAD_BOR');
1520: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1521: MSC_CL_BOM_ODS_LOAD.LOAD_BOR;
1522:
1523: ELSIF pTASKNUM= TASK_CALENDAR_DATE THEN
1524:

Line 1525: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');

1521: MSC_CL_BOM_ODS_LOAD.LOAD_BOR;
1522:
1523: ELSIF pTASKNUM= TASK_CALENDAR_DATE THEN
1524:
1525: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1526: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SETUP_ODS_LOAD.LOAD_CALENDAR_DATE');
1527: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1528: MSC_CL_SETUP_ODS_LOAD.LOAD_CALENDAR_DATE;
1529:

Line 1526: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SETUP_ODS_LOAD.LOAD_CALENDAR_DATE');

1522:
1523: ELSIF pTASKNUM= TASK_CALENDAR_DATE THEN
1524:
1525: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1526: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SETUP_ODS_LOAD.LOAD_CALENDAR_DATE');
1527: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1528: MSC_CL_SETUP_ODS_LOAD.LOAD_CALENDAR_DATE;
1529:
1530: ELSIF pTASKNUM= TASK_ITEM THEN

Line 1527: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

1523: ELSIF pTASKNUM= TASK_CALENDAR_DATE THEN
1524:
1525: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1526: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SETUP_ODS_LOAD.LOAD_CALENDAR_DATE');
1527: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1528: MSC_CL_SETUP_ODS_LOAD.LOAD_CALENDAR_DATE;
1529:
1530: ELSIF pTASKNUM= TASK_ITEM THEN
1531:

Line 1532: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');

1528: MSC_CL_SETUP_ODS_LOAD.LOAD_CALENDAR_DATE;
1529:
1530: ELSIF pTASKNUM= TASK_ITEM THEN
1531:
1532: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1533: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ITEM_ODS_LOAD.LOAD_ITEM');
1534: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1535: MSC_CL_ITEM_ODS_LOAD.LOAD_ITEM;
1536:

Line 1533: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ITEM_ODS_LOAD.LOAD_ITEM');

1529:
1530: ELSIF pTASKNUM= TASK_ITEM THEN
1531:
1532: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1533: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ITEM_ODS_LOAD.LOAD_ITEM');
1534: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1535: MSC_CL_ITEM_ODS_LOAD.LOAD_ITEM;
1536:
1537: /* as Supplier capacity is depenedent on item call load_supplier capacity

Line 1534: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

1530: ELSIF pTASKNUM= TASK_ITEM THEN
1531:
1532: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1533: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ITEM_ODS_LOAD.LOAD_ITEM');
1534: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1535: MSC_CL_ITEM_ODS_LOAD.LOAD_ITEM;
1536:
1537: /* as Supplier capacity is depenedent on item call load_supplier capacity
1538: after load_item (support for net change of ASL)*/

Line 1540: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');

1536:
1537: /* as Supplier capacity is depenedent on item call load_supplier capacity
1538: after load_item (support for net change of ASL)*/
1539:
1540: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1541: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ITEM_ODS_LOAD.LOAD_SUPPLIER_CAPACITY');
1542: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1543: MSC_CL_ITEM_ODS_LOAD.LOAD_SUPPLIER_CAPACITY;
1544:

Line 1541: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ITEM_ODS_LOAD.LOAD_SUPPLIER_CAPACITY');

1537: /* as Supplier capacity is depenedent on item call load_supplier capacity
1538: after load_item (support for net change of ASL)*/
1539:
1540: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1541: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ITEM_ODS_LOAD.LOAD_SUPPLIER_CAPACITY');
1542: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1543: MSC_CL_ITEM_ODS_LOAD.LOAD_SUPPLIER_CAPACITY;
1544:
1545: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');

Line 1542: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

1538: after load_item (support for net change of ASL)*/
1539:
1540: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1541: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ITEM_ODS_LOAD.LOAD_SUPPLIER_CAPACITY');
1542: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1543: MSC_CL_ITEM_ODS_LOAD.LOAD_SUPPLIER_CAPACITY;
1544:
1545: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1546: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SETUP_ODS_LOAD.CLEAN_LIAB_AGREEMENT');

Line 1545: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');

1541: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ITEM_ODS_LOAD.LOAD_SUPPLIER_CAPACITY');
1542: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1543: MSC_CL_ITEM_ODS_LOAD.LOAD_SUPPLIER_CAPACITY;
1544:
1545: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1546: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SETUP_ODS_LOAD.CLEAN_LIAB_AGREEMENT');
1547: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1548: MSC_CL_SETUP_ODS_LOAD.CLEAN_LIAB_AGREEMENT;
1549:

Line 1546: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SETUP_ODS_LOAD.CLEAN_LIAB_AGREEMENT');

1542: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1543: MSC_CL_ITEM_ODS_LOAD.LOAD_SUPPLIER_CAPACITY;
1544:
1545: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1546: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SETUP_ODS_LOAD.CLEAN_LIAB_AGREEMENT');
1547: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1548: MSC_CL_SETUP_ODS_LOAD.CLEAN_LIAB_AGREEMENT;
1549:
1550: ELSIF pTASKNUM= TASK_ABC_CLASSES THEN

Line 1547: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

1543: MSC_CL_ITEM_ODS_LOAD.LOAD_SUPPLIER_CAPACITY;
1544:
1545: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1546: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SETUP_ODS_LOAD.CLEAN_LIAB_AGREEMENT');
1547: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1548: MSC_CL_SETUP_ODS_LOAD.CLEAN_LIAB_AGREEMENT;
1549:
1550: ELSIF pTASKNUM= TASK_ABC_CLASSES THEN
1551:

Line 1552: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');

1548: MSC_CL_SETUP_ODS_LOAD.CLEAN_LIAB_AGREEMENT;
1549:
1550: ELSIF pTASKNUM= TASK_ABC_CLASSES THEN
1551:
1552: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1553: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ITEM_ODS_LOAD.LOAD_ABC_CLASSES');
1554: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1555: MSC_CL_ITEM_ODS_LOAD.LOAD_ABC_CLASSES;
1556:

Line 1553: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ITEM_ODS_LOAD.LOAD_ABC_CLASSES');

1549:
1550: ELSIF pTASKNUM= TASK_ABC_CLASSES THEN
1551:
1552: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1553: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ITEM_ODS_LOAD.LOAD_ABC_CLASSES');
1554: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1555: MSC_CL_ITEM_ODS_LOAD.LOAD_ABC_CLASSES;
1556:
1557: ELSIF pTASKNUM= TASK_RESOURCE THEN

Line 1554: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

1550: ELSIF pTASKNUM= TASK_ABC_CLASSES THEN
1551:
1552: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1553: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ITEM_ODS_LOAD.LOAD_ABC_CLASSES');
1554: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1555: MSC_CL_ITEM_ODS_LOAD.LOAD_ABC_CLASSES;
1556:
1557: ELSIF pTASKNUM= TASK_RESOURCE THEN
1558:

Line 1559: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');

1555: MSC_CL_ITEM_ODS_LOAD.LOAD_ABC_CLASSES;
1556:
1557: ELSIF pTASKNUM= TASK_RESOURCE THEN
1558:
1559: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1560: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_BOM_ODS_LOAD.LOAD_RESOURCE');
1561: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1562: -- BUG # 3020614
1563: -- The call to the procedure LOAD_RESOURCE is being

Line 1560: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_BOM_ODS_LOAD.LOAD_RESOURCE');

1556:
1557: ELSIF pTASKNUM= TASK_RESOURCE THEN
1558:
1559: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1560: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_BOM_ODS_LOAD.LOAD_RESOURCE');
1561: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1562: -- BUG # 3020614
1563: -- The call to the procedure LOAD_RESOURCE is being
1564: -- moved inside the procedure LOAD_CALENDAR_DATE.

Line 1561: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

1557: ELSIF pTASKNUM= TASK_RESOURCE THEN
1558:
1559: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1560: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_BOM_ODS_LOAD.LOAD_RESOURCE');
1561: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1562: -- BUG # 3020614
1563: -- The call to the procedure LOAD_RESOURCE is being
1564: -- moved inside the procedure LOAD_CALENDAR_DATE.
1565:

Line 1571: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');

1567:
1568: ELSIF pTASKNUM= TASK_SALES_ORDER THEN
1569:
1570: IF MSC_CL_SUPPLY_ODS_LOAD.IS_SUPPLIES_LOAD_DONE THEN
1571: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1572: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LOAD_SALES_ORDER');
1573: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1574: MSC_CL_DEMAND_ODS_LOAD.LOAD_SALES_ORDER;
1575:

Line 1572: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LOAD_SALES_ORDER');

1568: ELSIF pTASKNUM= TASK_SALES_ORDER THEN
1569:
1570: IF MSC_CL_SUPPLY_ODS_LOAD.IS_SUPPLIES_LOAD_DONE THEN
1571: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1572: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LOAD_SALES_ORDER');
1573: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1574: MSC_CL_DEMAND_ODS_LOAD.LOAD_SALES_ORDER;
1575:
1576: IF (v_is_complete_refresh = TRUE and v_is_so_complete_refresh = FALSE) THEN

Line 1573: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

1569:
1570: IF MSC_CL_SUPPLY_ODS_LOAD.IS_SUPPLIES_LOAD_DONE THEN
1571: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1572: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LOAD_SALES_ORDER');
1573: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1574: MSC_CL_DEMAND_ODS_LOAD.LOAD_SALES_ORDER;
1575:
1576: IF (v_is_complete_refresh = TRUE and v_is_so_complete_refresh = FALSE) THEN
1577: IF (v_apps_ver >= MSC_UTIL.G_APPS115 ) THEN

Line 1579: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');

1575:
1576: IF (v_is_complete_refresh = TRUE and v_is_so_complete_refresh = FALSE) THEN
1577: IF (v_apps_ver >= MSC_UTIL.G_APPS115 ) THEN
1578: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, ' Calling Linking of Sales Order for 11i source ...');
1579: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
1580: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LINK_SUPP_SO_DEMAND_11I2');
1581: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1582: MSC_CL_DEMAND_ODS_LOAD.LINK_SUPP_SO_DEMAND_11I2;
1583: -- Calling the Linking of external Sales orders for the fix 2353397 --

Line 1580: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LINK_SUPP_SO_DEMAND_11I2');

1576: IF (v_is_complete_refresh = TRUE and v_is_so_complete_refresh = FALSE) THEN
1577: IF (v_apps_ver >= MSC_UTIL.G_APPS115 ) THEN
1578: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, ' Calling Linking of Sales Order for 11i source ...');
1579: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
1580: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LINK_SUPP_SO_DEMAND_11I2');
1581: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1582: MSC_CL_DEMAND_ODS_LOAD.LINK_SUPP_SO_DEMAND_11I2;
1583: -- Calling the Linking of external Sales orders for the fix 2353397 --
1584: -- MSC_CL_DEMAND_ODS_LOAD.LINK_SUPP_SO_DEMAND_EXT;

Line 1581: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

1577: IF (v_apps_ver >= MSC_UTIL.G_APPS115 ) THEN
1578: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, ' Calling Linking of Sales Order for 11i source ...');
1579: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
1580: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LINK_SUPP_SO_DEMAND_11I2');
1581: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1582: MSC_CL_DEMAND_ODS_LOAD.LINK_SUPP_SO_DEMAND_11I2;
1583: -- Calling the Linking of external Sales orders for the fix 2353397 --
1584: -- MSC_CL_DEMAND_ODS_LOAD.LINK_SUPP_SO_DEMAND_EXT;
1585: ELSIF (v_apps_ver = MSC_UTIL.G_APPS110) THEN

Line 1587: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');

1583: -- Calling the Linking of external Sales orders for the fix 2353397 --
1584: -- MSC_CL_DEMAND_ODS_LOAD.LINK_SUPP_SO_DEMAND_EXT;
1585: ELSIF (v_apps_ver = MSC_UTIL.G_APPS110) THEN
1586: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, ' Calling Linking of Sales Order for 110 source ...');
1587: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
1588: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LINK_SUPP_SO_DEMAND_110');
1589: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1590: MSC_CL_DEMAND_ODS_LOAD.LINK_SUPP_SO_DEMAND_110;
1591: END IF;

Line 1588: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LINK_SUPP_SO_DEMAND_110');

1584: -- MSC_CL_DEMAND_ODS_LOAD.LINK_SUPP_SO_DEMAND_EXT;
1585: ELSIF (v_apps_ver = MSC_UTIL.G_APPS110) THEN
1586: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, ' Calling Linking of Sales Order for 110 source ...');
1587: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
1588: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LINK_SUPP_SO_DEMAND_110');
1589: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1590: MSC_CL_DEMAND_ODS_LOAD.LINK_SUPP_SO_DEMAND_110;
1591: END IF;
1592: END IF;

Line 1589: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

1585: ELSIF (v_apps_ver = MSC_UTIL.G_APPS110) THEN
1586: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, ' Calling Linking of Sales Order for 110 source ...');
1587: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
1588: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LINK_SUPP_SO_DEMAND_110');
1589: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1590: MSC_CL_DEMAND_ODS_LOAD.LINK_SUPP_SO_DEMAND_110;
1591: END IF;
1592: END IF;
1593:

Line 1601: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');

1597: END IF;
1598:
1599: ELSIF pTASKNUM= TASK_SUB_INVENTORY THEN
1600:
1601: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1602: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_SUB_INVENTORY');
1603: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1604: MSC_CL_OTHER_ODS_LOAD.LOAD_SUB_INVENTORY;
1605:

Line 1602: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_SUB_INVENTORY');

1598:
1599: ELSIF pTASKNUM= TASK_SUB_INVENTORY THEN
1600:
1601: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1602: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_SUB_INVENTORY');
1603: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1604: MSC_CL_OTHER_ODS_LOAD.LOAD_SUB_INVENTORY;
1605:
1606: ELSIF pTASKNUM= TASK_HARD_RESERVATION THEN

Line 1603: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

1599: ELSIF pTASKNUM= TASK_SUB_INVENTORY THEN
1600:
1601: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1602: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_SUB_INVENTORY');
1603: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1604: MSC_CL_OTHER_ODS_LOAD.LOAD_SUB_INVENTORY;
1605:
1606: ELSIF pTASKNUM= TASK_HARD_RESERVATION THEN
1607:

Line 1608: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');

1604: MSC_CL_OTHER_ODS_LOAD.LOAD_SUB_INVENTORY;
1605:
1606: ELSIF pTASKNUM= TASK_HARD_RESERVATION THEN
1607:
1608: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1609: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LOAD_HARD_RESERVATION');
1610: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1611: MSC_CL_DEMAND_ODS_LOAD.LOAD_HARD_RESERVATION;
1612:

Line 1609: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LOAD_HARD_RESERVATION');

1605:
1606: ELSIF pTASKNUM= TASK_HARD_RESERVATION THEN
1607:
1608: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1609: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LOAD_HARD_RESERVATION');
1610: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1611: MSC_CL_DEMAND_ODS_LOAD.LOAD_HARD_RESERVATION;
1612:
1613: ELSIF pTASKNUM= TASK_SOURCING THEN

Line 1610: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

1606: ELSIF pTASKNUM= TASK_HARD_RESERVATION THEN
1607:
1608: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1609: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LOAD_HARD_RESERVATION');
1610: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1611: MSC_CL_DEMAND_ODS_LOAD.LOAD_HARD_RESERVATION;
1612:
1613: ELSIF pTASKNUM= TASK_SOURCING THEN
1614:

Line 1615: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');

1611: MSC_CL_DEMAND_ODS_LOAD.LOAD_HARD_RESERVATION;
1612:
1613: ELSIF pTASKNUM= TASK_SOURCING THEN
1614:
1615: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1616: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_SOURCING');
1617: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1618: MSC_CL_OTHER_ODS_LOAD.LOAD_SOURCING;
1619: /* commented as a part of bug fix 5233688*/

Line 1616: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_SOURCING');

1612:
1613: ELSIF pTASKNUM= TASK_SOURCING THEN
1614:
1615: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1616: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_SOURCING');
1617: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1618: MSC_CL_OTHER_ODS_LOAD.LOAD_SOURCING;
1619: /* commented as a part of bug fix 5233688*/
1620:

Line 1617: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

1613: ELSIF pTASKNUM= TASK_SOURCING THEN
1614:
1615: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1616: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_SOURCING');
1617: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1618: MSC_CL_OTHER_ODS_LOAD.LOAD_SOURCING;
1619: /* commented as a part of bug fix 5233688*/
1620:
1621: ELSIF pTASKNUM= TASK_SUPPLIER_CAPACITY THEN

Line 1625: /* FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');

1621: ELSIF pTASKNUM= TASK_SUPPLIER_CAPACITY THEN
1622:
1623: NULL;
1624:
1625: /* FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1626: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'LOAD_SUPPLIER_CAPACITY');
1627: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1628: LOAD_SUPPLIER_CAPACITY;
1629: MSC_CL_SETUP_ODS_LOAD.CLEAN_LIAB_AGREEMENT ; */

Line 1626: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'LOAD_SUPPLIER_CAPACITY');

1622:
1623: NULL;
1624:
1625: /* FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1626: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'LOAD_SUPPLIER_CAPACITY');
1627: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1628: LOAD_SUPPLIER_CAPACITY;
1629: MSC_CL_SETUP_ODS_LOAD.CLEAN_LIAB_AGREEMENT ; */
1630:

Line 1627: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

1623: NULL;
1624:
1625: /* FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1626: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'LOAD_SUPPLIER_CAPACITY');
1627: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1628: LOAD_SUPPLIER_CAPACITY;
1629: MSC_CL_SETUP_ODS_LOAD.CLEAN_LIAB_AGREEMENT ; */
1630:
1631: /* SCE Change starts */

Line 1634: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');

1630:
1631: /* SCE Change starts */
1632: /* ODS load for Customer cross reference Items */
1633: ELSIF pTASKNUM= TASK_ITEM_CUSTOMERS THEN
1634: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1635: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'TASK_ITEM_CUSTOMERS');
1636: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1637: MSC_CL_SCE_COLLECTION.LOAD_ITEM_CUSTOMERS(v_instance_id);
1638:

Line 1635: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'TASK_ITEM_CUSTOMERS');

1631: /* SCE Change starts */
1632: /* ODS load for Customer cross reference Items */
1633: ELSIF pTASKNUM= TASK_ITEM_CUSTOMERS THEN
1634: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1635: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'TASK_ITEM_CUSTOMERS');
1636: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1637: MSC_CL_SCE_COLLECTION.LOAD_ITEM_CUSTOMERS(v_instance_id);
1638:
1639: ELSIF pTASKNUM= TASK_COMPANY_USERS THEN

Line 1636: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

1632: /* ODS load for Customer cross reference Items */
1633: ELSIF pTASKNUM= TASK_ITEM_CUSTOMERS THEN
1634: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1635: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'TASK_ITEM_CUSTOMERS');
1636: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1637: MSC_CL_SCE_COLLECTION.LOAD_ITEM_CUSTOMERS(v_instance_id);
1638:
1639: ELSIF pTASKNUM= TASK_COMPANY_USERS THEN
1640:

Line 1645: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');

1641: /* Perform this task only if MSC:Configuration is set to 'APS + SCE' or 'SCE. */
1642: IF (MSC_UTIL.G_MSC_CONFIGURATION = MSC_UTIL.G_CONF_APS_SCE
1643: OR MSC_UTIL.G_MSC_CONFIGURATION = MSC_UTIL.G_CONF_SCE) THEN
1644:
1645: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1646: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SCE_COLLECTION.LOAD_USER_COMPANY');
1647: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1648: MSC_CL_SCE_COLLECTION.LOAD_USER_COMPANY(v_instance_id);
1649:

Line 1646: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SCE_COLLECTION.LOAD_USER_COMPANY');

1642: IF (MSC_UTIL.G_MSC_CONFIGURATION = MSC_UTIL.G_CONF_APS_SCE
1643: OR MSC_UTIL.G_MSC_CONFIGURATION = MSC_UTIL.G_CONF_SCE) THEN
1644:
1645: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1646: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SCE_COLLECTION.LOAD_USER_COMPANY');
1647: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1648: MSC_CL_SCE_COLLECTION.LOAD_USER_COMPANY(v_instance_id);
1649:
1650: END IF;

Line 1647: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

1643: OR MSC_UTIL.G_MSC_CONFIGURATION = MSC_UTIL.G_CONF_SCE) THEN
1644:
1645: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1646: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SCE_COLLECTION.LOAD_USER_COMPANY');
1647: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1648: MSC_CL_SCE_COLLECTION.LOAD_USER_COMPANY(v_instance_id);
1649:
1650: END IF;
1651: /* SCE Change ends */

Line 1655: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');

1651: /* SCE Change ends */
1652:
1653: ELSIF pTASKNUM= TASK_CATEGORY THEN
1654:
1655: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1656: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ITEM_ODS_LOAD.LOAD_CATEGORY');
1657: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1658: MSC_CL_ITEM_ODS_LOAD.LOAD_CATEGORY;
1659:

Line 1656: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ITEM_ODS_LOAD.LOAD_CATEGORY');

1652:
1653: ELSIF pTASKNUM= TASK_CATEGORY THEN
1654:
1655: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1656: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ITEM_ODS_LOAD.LOAD_CATEGORY');
1657: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1658: MSC_CL_ITEM_ODS_LOAD.LOAD_CATEGORY;
1659:
1660: ELSIF pTASKNUM= TASK_BOM_COMPONENTS THEN

Line 1657: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

1653: ELSIF pTASKNUM= TASK_CATEGORY THEN
1654:
1655: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1656: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ITEM_ODS_LOAD.LOAD_CATEGORY');
1657: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1658: MSC_CL_ITEM_ODS_LOAD.LOAD_CATEGORY;
1659:
1660: ELSIF pTASKNUM= TASK_BOM_COMPONENTS THEN
1661:

Line 1662: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');

1658: MSC_CL_ITEM_ODS_LOAD.LOAD_CATEGORY;
1659:
1660: ELSIF pTASKNUM= TASK_BOM_COMPONENTS THEN
1661:
1662: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1663: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_BOM_ODS_LOAD.LOAD_BOM_COMPONENTS');
1664: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1665: MSC_CL_BOM_ODS_LOAD.LOAD_BOM_COMPONENTS;
1666:

Line 1663: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_BOM_ODS_LOAD.LOAD_BOM_COMPONENTS');

1659:
1660: ELSIF pTASKNUM= TASK_BOM_COMPONENTS THEN
1661:
1662: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1663: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_BOM_ODS_LOAD.LOAD_BOM_COMPONENTS');
1664: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1665: MSC_CL_BOM_ODS_LOAD.LOAD_BOM_COMPONENTS;
1666:
1667: ELSIF pTASKNUM= TASK_BOM THEN

Line 1664: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

1660: ELSIF pTASKNUM= TASK_BOM_COMPONENTS THEN
1661:
1662: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1663: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_BOM_ODS_LOAD.LOAD_BOM_COMPONENTS');
1664: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1665: MSC_CL_BOM_ODS_LOAD.LOAD_BOM_COMPONENTS;
1666:
1667: ELSIF pTASKNUM= TASK_BOM THEN
1668:

Line 1669: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');

1665: MSC_CL_BOM_ODS_LOAD.LOAD_BOM_COMPONENTS;
1666:
1667: ELSIF pTASKNUM= TASK_BOM THEN
1668:
1669: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1670: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_BOM_ODS_LOAD.LOAD_BOM');
1671: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1672: MSC_CL_BOM_ODS_LOAD.LOAD_BOM;
1673:

Line 1670: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_BOM_ODS_LOAD.LOAD_BOM');

1666:
1667: ELSIF pTASKNUM= TASK_BOM THEN
1668:
1669: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1670: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_BOM_ODS_LOAD.LOAD_BOM');
1671: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1672: MSC_CL_BOM_ODS_LOAD.LOAD_BOM;
1673:
1674: ELSIF pTASKNUM= TASK_COMPONENT_SUBSTITUTE THEN

Line 1671: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

1667: ELSIF pTASKNUM= TASK_BOM THEN
1668:
1669: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1670: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_BOM_ODS_LOAD.LOAD_BOM');
1671: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1672: MSC_CL_BOM_ODS_LOAD.LOAD_BOM;
1673:
1674: ELSIF pTASKNUM= TASK_COMPONENT_SUBSTITUTE THEN
1675:

Line 1676: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');

1672: MSC_CL_BOM_ODS_LOAD.LOAD_BOM;
1673:
1674: ELSIF pTASKNUM= TASK_COMPONENT_SUBSTITUTE THEN
1675:
1676: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1677: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_BOM_ODS_LOAD.LOAD_COMPONENT_SUBSTITUTE');
1678: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1679: MSC_CL_BOM_ODS_LOAD.LOAD_COMPONENT_SUBSTITUTE;
1680:

Line 1677: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_BOM_ODS_LOAD.LOAD_COMPONENT_SUBSTITUTE');

1673:
1674: ELSIF pTASKNUM= TASK_COMPONENT_SUBSTITUTE THEN
1675:
1676: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1677: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_BOM_ODS_LOAD.LOAD_COMPONENT_SUBSTITUTE');
1678: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1679: MSC_CL_BOM_ODS_LOAD.LOAD_COMPONENT_SUBSTITUTE;
1680:
1681: ELSIF pTASKNUM= TASK_ROUTING THEN

Line 1678: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

1674: ELSIF pTASKNUM= TASK_COMPONENT_SUBSTITUTE THEN
1675:
1676: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1677: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_BOM_ODS_LOAD.LOAD_COMPONENT_SUBSTITUTE');
1678: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1679: MSC_CL_BOM_ODS_LOAD.LOAD_COMPONENT_SUBSTITUTE;
1680:
1681: ELSIF pTASKNUM= TASK_ROUTING THEN
1682:

Line 1683: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');

1679: MSC_CL_BOM_ODS_LOAD.LOAD_COMPONENT_SUBSTITUTE;
1680:
1681: ELSIF pTASKNUM= TASK_ROUTING THEN
1682:
1683: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1684: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ROUTING_ODS_LOAD.LOAD_ROUTING');
1685: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1686: MSC_CL_ROUTING_ODS_LOAD.LOAD_ROUTING;
1687:

Line 1684: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ROUTING_ODS_LOAD.LOAD_ROUTING');

1680:
1681: ELSIF pTASKNUM= TASK_ROUTING THEN
1682:
1683: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1684: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ROUTING_ODS_LOAD.LOAD_ROUTING');
1685: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1686: MSC_CL_ROUTING_ODS_LOAD.LOAD_ROUTING;
1687:
1688: ELSIF pTASKNUM= TASK_ROUTING_OPERATIONS THEN

Line 1685: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

1681: ELSIF pTASKNUM= TASK_ROUTING THEN
1682:
1683: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1684: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ROUTING_ODS_LOAD.LOAD_ROUTING');
1685: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1686: MSC_CL_ROUTING_ODS_LOAD.LOAD_ROUTING;
1687:
1688: ELSIF pTASKNUM= TASK_ROUTING_OPERATIONS THEN
1689:

Line 1690: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');

1686: MSC_CL_ROUTING_ODS_LOAD.LOAD_ROUTING;
1687:
1688: ELSIF pTASKNUM= TASK_ROUTING_OPERATIONS THEN
1689:
1690: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1691: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ROUTING_ODS_LOAD.LOAD_ROUTING_OPERATIONS');
1692: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1693: MSC_CL_ROUTING_ODS_LOAD.LOAD_ROUTING_OPERATIONS;
1694: ELSIF pTASKNUM= TASK_OPERATION_RESOURCES THEN

Line 1691: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ROUTING_ODS_LOAD.LOAD_ROUTING_OPERATIONS');

1687:
1688: ELSIF pTASKNUM= TASK_ROUTING_OPERATIONS THEN
1689:
1690: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1691: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ROUTING_ODS_LOAD.LOAD_ROUTING_OPERATIONS');
1692: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1693: MSC_CL_ROUTING_ODS_LOAD.LOAD_ROUTING_OPERATIONS;
1694: ELSIF pTASKNUM= TASK_OPERATION_RESOURCES THEN
1695:

Line 1692: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

1688: ELSIF pTASKNUM= TASK_ROUTING_OPERATIONS THEN
1689:
1690: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1691: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ROUTING_ODS_LOAD.LOAD_ROUTING_OPERATIONS');
1692: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1693: MSC_CL_ROUTING_ODS_LOAD.LOAD_ROUTING_OPERATIONS;
1694: ELSIF pTASKNUM= TASK_OPERATION_RESOURCES THEN
1695:
1696: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');

Line 1696: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');

1692: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1693: MSC_CL_ROUTING_ODS_LOAD.LOAD_ROUTING_OPERATIONS;
1694: ELSIF pTASKNUM= TASK_OPERATION_RESOURCES THEN
1695:
1696: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1697: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ROUTING_ODS_LOAD.LOAD_OPERATION_RESOURCES');
1698: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1699: MSC_CL_ROUTING_ODS_LOAD.LOAD_OPERATION_RESOURCES;
1700: ELSIF pTASKNUM= TASK_OP_RESOURCE_SEQ THEN

Line 1697: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ROUTING_ODS_LOAD.LOAD_OPERATION_RESOURCES');

1693: MSC_CL_ROUTING_ODS_LOAD.LOAD_ROUTING_OPERATIONS;
1694: ELSIF pTASKNUM= TASK_OPERATION_RESOURCES THEN
1695:
1696: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1697: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ROUTING_ODS_LOAD.LOAD_OPERATION_RESOURCES');
1698: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1699: MSC_CL_ROUTING_ODS_LOAD.LOAD_OPERATION_RESOURCES;
1700: ELSIF pTASKNUM= TASK_OP_RESOURCE_SEQ THEN
1701:

Line 1698: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

1694: ELSIF pTASKNUM= TASK_OPERATION_RESOURCES THEN
1695:
1696: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1697: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ROUTING_ODS_LOAD.LOAD_OPERATION_RESOURCES');
1698: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1699: MSC_CL_ROUTING_ODS_LOAD.LOAD_OPERATION_RESOURCES;
1700: ELSIF pTASKNUM= TASK_OP_RESOURCE_SEQ THEN
1701:
1702: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');

Line 1702: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');

1698: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1699: MSC_CL_ROUTING_ODS_LOAD.LOAD_OPERATION_RESOURCES;
1700: ELSIF pTASKNUM= TASK_OP_RESOURCE_SEQ THEN
1701:
1702: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1703: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ROUTING_ODS_LOAD.LOAD_OP_RESOURCE_SEQ');
1704: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1705: MSC_CL_ROUTING_ODS_LOAD.LOAD_OP_RESOURCE_SEQ;
1706: ELSIF pTASKNUM= TASK_PROCESS_EFFECTIVITY THEN

Line 1703: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ROUTING_ODS_LOAD.LOAD_OP_RESOURCE_SEQ');

1699: MSC_CL_ROUTING_ODS_LOAD.LOAD_OPERATION_RESOURCES;
1700: ELSIF pTASKNUM= TASK_OP_RESOURCE_SEQ THEN
1701:
1702: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1703: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ROUTING_ODS_LOAD.LOAD_OP_RESOURCE_SEQ');
1704: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1705: MSC_CL_ROUTING_ODS_LOAD.LOAD_OP_RESOURCE_SEQ;
1706: ELSIF pTASKNUM= TASK_PROCESS_EFFECTIVITY THEN
1707:

Line 1704: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

1700: ELSIF pTASKNUM= TASK_OP_RESOURCE_SEQ THEN
1701:
1702: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1703: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ROUTING_ODS_LOAD.LOAD_OP_RESOURCE_SEQ');
1704: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1705: MSC_CL_ROUTING_ODS_LOAD.LOAD_OP_RESOURCE_SEQ;
1706: ELSIF pTASKNUM= TASK_PROCESS_EFFECTIVITY THEN
1707:
1708: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');

Line 1708: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');

1704: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1705: MSC_CL_ROUTING_ODS_LOAD.LOAD_OP_RESOURCE_SEQ;
1706: ELSIF pTASKNUM= TASK_PROCESS_EFFECTIVITY THEN
1707:
1708: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1709: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_BOM_ODS_LOAD.LOAD_PROCESS_EFFECTIVITY');
1710: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1711: MSC_CL_BOM_ODS_LOAD.LOAD_PROCESS_EFFECTIVITY;
1712: ELSIF pTASKNUM= TASK_OPERATION_COMPONENTS THEN

Line 1709: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_BOM_ODS_LOAD.LOAD_PROCESS_EFFECTIVITY');

1705: MSC_CL_ROUTING_ODS_LOAD.LOAD_OP_RESOURCE_SEQ;
1706: ELSIF pTASKNUM= TASK_PROCESS_EFFECTIVITY THEN
1707:
1708: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1709: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_BOM_ODS_LOAD.LOAD_PROCESS_EFFECTIVITY');
1710: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1711: MSC_CL_BOM_ODS_LOAD.LOAD_PROCESS_EFFECTIVITY;
1712: ELSIF pTASKNUM= TASK_OPERATION_COMPONENTS THEN
1713:

Line 1710: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

1706: ELSIF pTASKNUM= TASK_PROCESS_EFFECTIVITY THEN
1707:
1708: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1709: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_BOM_ODS_LOAD.LOAD_PROCESS_EFFECTIVITY');
1710: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1711: MSC_CL_BOM_ODS_LOAD.LOAD_PROCESS_EFFECTIVITY;
1712: ELSIF pTASKNUM= TASK_OPERATION_COMPONENTS THEN
1713:
1714: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');

Line 1714: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');

1710: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1711: MSC_CL_BOM_ODS_LOAD.LOAD_PROCESS_EFFECTIVITY;
1712: ELSIF pTASKNUM= TASK_OPERATION_COMPONENTS THEN
1713:
1714: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1715: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ROUTING_ODS_LOAD.LOAD_OPERATION_COMPONENTS');
1716: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1717: MSC_CL_ROUTING_ODS_LOAD.LOAD_OPERATION_COMPONENTS;
1718: ELSIF pTASKNUM= TASK_OPERATION_NETWORKS THEN

Line 1715: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ROUTING_ODS_LOAD.LOAD_OPERATION_COMPONENTS');

1711: MSC_CL_BOM_ODS_LOAD.LOAD_PROCESS_EFFECTIVITY;
1712: ELSIF pTASKNUM= TASK_OPERATION_COMPONENTS THEN
1713:
1714: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1715: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ROUTING_ODS_LOAD.LOAD_OPERATION_COMPONENTS');
1716: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1717: MSC_CL_ROUTING_ODS_LOAD.LOAD_OPERATION_COMPONENTS;
1718: ELSIF pTASKNUM= TASK_OPERATION_NETWORKS THEN
1719:

Line 1716: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

1712: ELSIF pTASKNUM= TASK_OPERATION_COMPONENTS THEN
1713:
1714: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1715: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ROUTING_ODS_LOAD.LOAD_OPERATION_COMPONENTS');
1716: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1717: MSC_CL_ROUTING_ODS_LOAD.LOAD_OPERATION_COMPONENTS;
1718: ELSIF pTASKNUM= TASK_OPERATION_NETWORKS THEN
1719:
1720: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');

Line 1720: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');

1716: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1717: MSC_CL_ROUTING_ODS_LOAD.LOAD_OPERATION_COMPONENTS;
1718: ELSIF pTASKNUM= TASK_OPERATION_NETWORKS THEN
1719:
1720: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1721: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ROUTING_ODS_LOAD.LOAD_OPERATION_NETWORKS');
1722: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1723: MSC_CL_ROUTING_ODS_LOAD.LOAD_OPERATION_NETWORKS;
1724:

Line 1721: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ROUTING_ODS_LOAD.LOAD_OPERATION_NETWORKS');

1717: MSC_CL_ROUTING_ODS_LOAD.LOAD_OPERATION_COMPONENTS;
1718: ELSIF pTASKNUM= TASK_OPERATION_NETWORKS THEN
1719:
1720: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1721: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ROUTING_ODS_LOAD.LOAD_OPERATION_NETWORKS');
1722: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1723: MSC_CL_ROUTING_ODS_LOAD.LOAD_OPERATION_NETWORKS;
1724:
1725: ELSIF pTASKNUM= TASK_UNIT_NUMBER THEN

Line 1722: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

1718: ELSIF pTASKNUM= TASK_OPERATION_NETWORKS THEN
1719:
1720: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1721: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ROUTING_ODS_LOAD.LOAD_OPERATION_NETWORKS');
1722: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1723: MSC_CL_ROUTING_ODS_LOAD.LOAD_OPERATION_NETWORKS;
1724:
1725: ELSIF pTASKNUM= TASK_UNIT_NUMBER THEN
1726:

Line 1727: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');

1723: MSC_CL_ROUTING_ODS_LOAD.LOAD_OPERATION_NETWORKS;
1724:
1725: ELSIF pTASKNUM= TASK_UNIT_NUMBER THEN
1726:
1727: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1728: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_UNIT_NUMBER');
1729: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1730: MSC_CL_OTHER_ODS_LOAD.LOAD_UNIT_NUMBER;
1731:

Line 1728: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_UNIT_NUMBER');

1724:
1725: ELSIF pTASKNUM= TASK_UNIT_NUMBER THEN
1726:
1727: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1728: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_UNIT_NUMBER');
1729: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1730: MSC_CL_OTHER_ODS_LOAD.LOAD_UNIT_NUMBER;
1731:
1732: ELSIF pTASKNUM= TASK_SAFETY_STOCK THEN

Line 1729: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

1725: ELSIF pTASKNUM= TASK_UNIT_NUMBER THEN
1726:
1727: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1728: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_UNIT_NUMBER');
1729: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1730: MSC_CL_OTHER_ODS_LOAD.LOAD_UNIT_NUMBER;
1731:
1732: ELSIF pTASKNUM= TASK_SAFETY_STOCK THEN
1733:

Line 1734: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');

1730: MSC_CL_OTHER_ODS_LOAD.LOAD_UNIT_NUMBER;
1731:
1732: ELSIF pTASKNUM= TASK_SAFETY_STOCK THEN
1733:
1734: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1735: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_SAFETY_STOCK');
1736: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1737: MSC_CL_OTHER_ODS_LOAD.LOAD_SAFETY_STOCK;
1738:

Line 1735: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_SAFETY_STOCK');

1731:
1732: ELSIF pTASKNUM= TASK_SAFETY_STOCK THEN
1733:
1734: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1735: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_SAFETY_STOCK');
1736: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1737: MSC_CL_OTHER_ODS_LOAD.LOAD_SAFETY_STOCK;
1738:
1739: ELSIF pTASKNUM= TASK_PROJECT THEN

Line 1736: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

1732: ELSIF pTASKNUM= TASK_SAFETY_STOCK THEN
1733:
1734: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1735: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_SAFETY_STOCK');
1736: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1737: MSC_CL_OTHER_ODS_LOAD.LOAD_SAFETY_STOCK;
1738:
1739: ELSIF pTASKNUM= TASK_PROJECT THEN
1740:

Line 1741: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');

1737: MSC_CL_OTHER_ODS_LOAD.LOAD_SAFETY_STOCK;
1738:
1739: ELSIF pTASKNUM= TASK_PROJECT THEN
1740:
1741: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1742: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_PROJECT');
1743: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1744: MSC_CL_OTHER_ODS_LOAD.LOAD_PROJECT;
1745:

Line 1742: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_PROJECT');

1738:
1739: ELSIF pTASKNUM= TASK_PROJECT THEN
1740:
1741: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1742: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_PROJECT');
1743: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1744: MSC_CL_OTHER_ODS_LOAD.LOAD_PROJECT;
1745:
1746: ELSIF pTASKNUM= TASK_PARAMETER THEN

Line 1743: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

1739: ELSIF pTASKNUM= TASK_PROJECT THEN
1740:
1741: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1742: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_PROJECT');
1743: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1744: MSC_CL_OTHER_ODS_LOAD.LOAD_PROJECT;
1745:
1746: ELSIF pTASKNUM= TASK_PARAMETER THEN
1747:

Line 1757: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');

1753:
1754: ELSIF pTASKNUM= TASK_BIS_PFMC_MEASURES THEN
1755:
1756: IF v_apps_ver <> MSC_UTIL.G_APPS107 THEN
1757: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1758: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_BIS_PFMC_MEASURES');
1759: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1760: MSC_CL_OTHER_ODS_LOAD.LOAD_BIS_PFMC_MEASURES;
1761: END IF;

Line 1758: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_BIS_PFMC_MEASURES');

1754: ELSIF pTASKNUM= TASK_BIS_PFMC_MEASURES THEN
1755:
1756: IF v_apps_ver <> MSC_UTIL.G_APPS107 THEN
1757: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1758: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_BIS_PFMC_MEASURES');
1759: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1760: MSC_CL_OTHER_ODS_LOAD.LOAD_BIS_PFMC_MEASURES;
1761: END IF;
1762:

Line 1759: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

1755:
1756: IF v_apps_ver <> MSC_UTIL.G_APPS107 THEN
1757: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1758: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_BIS_PFMC_MEASURES');
1759: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1760: MSC_CL_OTHER_ODS_LOAD.LOAD_BIS_PFMC_MEASURES;
1761: END IF;
1762:
1763: ELSIF pTASKNUM= TASK_BIS_TARGET_LEVELS THEN

Line 1766: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');

1762:
1763: ELSIF pTASKNUM= TASK_BIS_TARGET_LEVELS THEN
1764:
1765: IF v_apps_ver <> MSC_UTIL.G_APPS107 THEN
1766: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1767: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_BIS_TARGET_LEVELS');
1768: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1769: MSC_CL_OTHER_ODS_LOAD.LOAD_BIS_TARGET_LEVELS;
1770: END IF;

Line 1767: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_BIS_TARGET_LEVELS');

1763: ELSIF pTASKNUM= TASK_BIS_TARGET_LEVELS THEN
1764:
1765: IF v_apps_ver <> MSC_UTIL.G_APPS107 THEN
1766: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1767: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_BIS_TARGET_LEVELS');
1768: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1769: MSC_CL_OTHER_ODS_LOAD.LOAD_BIS_TARGET_LEVELS;
1770: END IF;
1771:

Line 1768: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

1764:
1765: IF v_apps_ver <> MSC_UTIL.G_APPS107 THEN
1766: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1767: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_BIS_TARGET_LEVELS');
1768: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1769: MSC_CL_OTHER_ODS_LOAD.LOAD_BIS_TARGET_LEVELS;
1770: END IF;
1771:
1772: ELSIF pTASKNUM= TASK_BIS_TARGETS THEN

Line 1775: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');

1771:
1772: ELSIF pTASKNUM= TASK_BIS_TARGETS THEN
1773:
1774: IF v_apps_ver <> MSC_UTIL.G_APPS107 THEN
1775: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1776: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_BIS_TARGETS');
1777: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1778: MSC_CL_OTHER_ODS_LOAD.LOAD_BIS_TARGETS;
1779: END IF;

Line 1776: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_BIS_TARGETS');

1772: ELSIF pTASKNUM= TASK_BIS_TARGETS THEN
1773:
1774: IF v_apps_ver <> MSC_UTIL.G_APPS107 THEN
1775: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1776: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_BIS_TARGETS');
1777: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1778: MSC_CL_OTHER_ODS_LOAD.LOAD_BIS_TARGETS;
1779: END IF;
1780:

Line 1777: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

1773:
1774: IF v_apps_ver <> MSC_UTIL.G_APPS107 THEN
1775: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1776: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_BIS_TARGETS');
1777: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1778: MSC_CL_OTHER_ODS_LOAD.LOAD_BIS_TARGETS;
1779: END IF;
1780:
1781: ELSIF pTASKNUM= TASK_BIS_BUSINESS_PLANS THEN

Line 1784: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');

1780:
1781: ELSIF pTASKNUM= TASK_BIS_BUSINESS_PLANS THEN
1782:
1783: IF v_apps_ver <> MSC_UTIL.G_APPS107 THEN
1784: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1785: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_BIS_BUSINESS_PLANS');
1786: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1787: MSC_CL_OTHER_ODS_LOAD.LOAD_BIS_BUSINESS_PLANS;
1788: END IF;

Line 1785: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_BIS_BUSINESS_PLANS');

1781: ELSIF pTASKNUM= TASK_BIS_BUSINESS_PLANS THEN
1782:
1783: IF v_apps_ver <> MSC_UTIL.G_APPS107 THEN
1784: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1785: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_BIS_BUSINESS_PLANS');
1786: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1787: MSC_CL_OTHER_ODS_LOAD.LOAD_BIS_BUSINESS_PLANS;
1788: END IF;
1789:

Line 1786: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

1782:
1783: IF v_apps_ver <> MSC_UTIL.G_APPS107 THEN
1784: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1785: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_BIS_BUSINESS_PLANS');
1786: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1787: MSC_CL_OTHER_ODS_LOAD.LOAD_BIS_BUSINESS_PLANS;
1788: END IF;
1789:
1790: ELSIF pTASKNUM= TASK_BIS_PERIODS THEN

Line 1792: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');

1788: END IF;
1789:
1790: ELSIF pTASKNUM= TASK_BIS_PERIODS THEN
1791:
1792: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1793: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_BIS_PERIODS');
1794: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1795: MSC_CL_OTHER_ODS_LOAD.LOAD_BIS_PERIODS;
1796:

Line 1793: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_BIS_PERIODS');

1789:
1790: ELSIF pTASKNUM= TASK_BIS_PERIODS THEN
1791:
1792: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1793: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_BIS_PERIODS');
1794: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1795: MSC_CL_OTHER_ODS_LOAD.LOAD_BIS_PERIODS;
1796:
1797: ELSIF pTASKNUM= TASK_ATP_RULES THEN

Line 1794: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

1790: ELSIF pTASKNUM= TASK_BIS_PERIODS THEN
1791:
1792: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1793: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_BIS_PERIODS');
1794: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1795: MSC_CL_OTHER_ODS_LOAD.LOAD_BIS_PERIODS;
1796:
1797: ELSIF pTASKNUM= TASK_ATP_RULES THEN
1798:

Line 1799: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');

1795: MSC_CL_OTHER_ODS_LOAD.LOAD_BIS_PERIODS;
1796:
1797: ELSIF pTASKNUM= TASK_ATP_RULES THEN
1798:
1799: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1800: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_ATP_RULES');
1801: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1802: MSC_CL_OTHER_ODS_LOAD.LOAD_ATP_RULES;
1803:

Line 1800: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_ATP_RULES');

1796:
1797: ELSIF pTASKNUM= TASK_ATP_RULES THEN
1798:
1799: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1800: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_ATP_RULES');
1801: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1802: MSC_CL_OTHER_ODS_LOAD.LOAD_ATP_RULES;
1803:
1804: ELSIF pTASKNUM= TASK_NET_RESOURCE_AVAIL THEN

Line 1801: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

1797: ELSIF pTASKNUM= TASK_ATP_RULES THEN
1798:
1799: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1800: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_ATP_RULES');
1801: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1802: MSC_CL_OTHER_ODS_LOAD.LOAD_ATP_RULES;
1803:
1804: ELSIF pTASKNUM= TASK_NET_RESOURCE_AVAIL THEN
1805:

Line 1806: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');

1802: MSC_CL_OTHER_ODS_LOAD.LOAD_ATP_RULES;
1803:
1804: ELSIF pTASKNUM= TASK_NET_RESOURCE_AVAIL THEN
1805:
1806: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1807: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_RESOURCE_AVAILABILITY.LOAD_NET_RESOURCE_AVAIL');
1808: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1809: MSC_RESOURCE_AVAILABILITY.LOAD_NET_RESOURCE_AVAIL;
1810:

Line 1807: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_RESOURCE_AVAILABILITY.LOAD_NET_RESOURCE_AVAIL');

1803:
1804: ELSIF pTASKNUM= TASK_NET_RESOURCE_AVAIL THEN
1805:
1806: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1807: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_RESOURCE_AVAILABILITY.LOAD_NET_RESOURCE_AVAIL');
1808: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1809: MSC_RESOURCE_AVAILABILITY.LOAD_NET_RESOURCE_AVAIL;
1810:
1811: ELSIF pTASKNUM= TASK_PLANNERS THEN

Line 1808: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

1804: ELSIF pTASKNUM= TASK_NET_RESOURCE_AVAIL THEN
1805:
1806: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1807: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_RESOURCE_AVAILABILITY.LOAD_NET_RESOURCE_AVAIL');
1808: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1809: MSC_RESOURCE_AVAILABILITY.LOAD_NET_RESOURCE_AVAIL;
1810:
1811: ELSIF pTASKNUM= TASK_PLANNERS THEN
1812:

Line 1813: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');

1809: MSC_RESOURCE_AVAILABILITY.LOAD_NET_RESOURCE_AVAIL;
1810:
1811: ELSIF pTASKNUM= TASK_PLANNERS THEN
1812:
1813: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1814: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_PLANNERS');
1815: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1816: MSC_CL_OTHER_ODS_LOAD.LOAD_PLANNERS;
1817:

Line 1814: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_PLANNERS');

1810:
1811: ELSIF pTASKNUM= TASK_PLANNERS THEN
1812:
1813: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1814: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_PLANNERS');
1815: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1816: MSC_CL_OTHER_ODS_LOAD.LOAD_PLANNERS;
1817:
1818: ELSIF pTASKNUM= TASK_DEMAND_CLASS THEN

Line 1815: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

1811: ELSIF pTASKNUM= TASK_PLANNERS THEN
1812:
1813: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1814: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_PLANNERS');
1815: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1816: MSC_CL_OTHER_ODS_LOAD.LOAD_PLANNERS;
1817:
1818: ELSIF pTASKNUM= TASK_DEMAND_CLASS THEN
1819:

Line 1820: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');

1816: MSC_CL_OTHER_ODS_LOAD.LOAD_PLANNERS;
1817:
1818: ELSIF pTASKNUM= TASK_DEMAND_CLASS THEN
1819:
1820: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1821: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_DEMAND_CLASS');
1822: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1823: MSC_CL_OTHER_ODS_LOAD.LOAD_DEMAND_CLASS;
1824:

Line 1821: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_DEMAND_CLASS');

1817:
1818: ELSIF pTASKNUM= TASK_DEMAND_CLASS THEN
1819:
1820: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1821: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_DEMAND_CLASS');
1822: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1823: MSC_CL_OTHER_ODS_LOAD.LOAD_DEMAND_CLASS;
1824:
1825: ELSIF pTASKNUM = TASK_ITEM_SUBSTITUTES THEN

Line 1822: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

1818: ELSIF pTASKNUM= TASK_DEMAND_CLASS THEN
1819:
1820: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1821: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_DEMAND_CLASS');
1822: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1823: MSC_CL_OTHER_ODS_LOAD.LOAD_DEMAND_CLASS;
1824:
1825: ELSIF pTASKNUM = TASK_ITEM_SUBSTITUTES THEN
1826:

Line 1829: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');

1825: ELSIF pTASKNUM = TASK_ITEM_SUBSTITUTES THEN
1826:
1827: IF (v_apps_ver >= MSC_UTIL.G_APPS115) OR v_is_legacy_refresh THEN
1828:
1829: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1830: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ITEM_ODS_LOAD.LOAD_ITEM_SUBSTITUTES');
1831: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1832: MSC_CL_ITEM_ODS_LOAD.LOAD_ITEM_SUBSTITUTES;
1833:

Line 1830: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ITEM_ODS_LOAD.LOAD_ITEM_SUBSTITUTES');

1826:
1827: IF (v_apps_ver >= MSC_UTIL.G_APPS115) OR v_is_legacy_refresh THEN
1828:
1829: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1830: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ITEM_ODS_LOAD.LOAD_ITEM_SUBSTITUTES');
1831: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1832: MSC_CL_ITEM_ODS_LOAD.LOAD_ITEM_SUBSTITUTES;
1833:
1834: END IF;

Line 1831: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

1827: IF (v_apps_ver >= MSC_UTIL.G_APPS115) OR v_is_legacy_refresh THEN
1828:
1829: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1830: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ITEM_ODS_LOAD.LOAD_ITEM_SUBSTITUTES');
1831: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1832: MSC_CL_ITEM_ODS_LOAD.LOAD_ITEM_SUBSTITUTES;
1833:
1834: END IF;
1835:

Line 1840: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');

1836: ELSIF pTASKNUM= TASK_TRIP THEN
1837:
1838: IF (v_apps_ver >= MSC_UTIL.G_APPS115) OR v_is_legacy_refresh THEN
1839:
1840: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1841: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_TRIP');
1842: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1843: MSC_CL_OTHER_ODS_LOAD.LOAD_TRIP;
1844:

Line 1841: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_TRIP');

1837:
1838: IF (v_apps_ver >= MSC_UTIL.G_APPS115) OR v_is_legacy_refresh THEN
1839:
1840: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1841: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_TRIP');
1842: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1843: MSC_CL_OTHER_ODS_LOAD.LOAD_TRIP;
1844:
1845: END IF;

Line 1842: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

1838: IF (v_apps_ver >= MSC_UTIL.G_APPS115) OR v_is_legacy_refresh THEN
1839:
1840: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1841: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_TRIP');
1842: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1843: MSC_CL_OTHER_ODS_LOAD.LOAD_TRIP;
1844:
1845: END IF;
1846: /* ds change start */

Line 1849: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');

1845: END IF;
1846: /* ds change start */
1847: ELSIF pTASKNUM= TASK_RES_INST_REQ THEN
1848: IF MSC_CL_SUPPLY_ODS_LOAD.IS_SUPPLIES_LOAD_DONE THEN
1849: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1850: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_WIP_ODS_LOAD.LOAD_RES_INST_REQ');
1851: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1852: MSC_CL_WIP_ODS_LOAD.LOAD_RES_INST_REQ;
1853: ELSE

Line 1850: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_WIP_ODS_LOAD.LOAD_RES_INST_REQ');

1846: /* ds change start */
1847: ELSIF pTASKNUM= TASK_RES_INST_REQ THEN
1848: IF MSC_CL_SUPPLY_ODS_LOAD.IS_SUPPLIES_LOAD_DONE THEN
1849: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1850: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_WIP_ODS_LOAD.LOAD_RES_INST_REQ');
1851: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1852: MSC_CL_WIP_ODS_LOAD.LOAD_RES_INST_REQ;
1853: ELSE
1854: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, 'Loading of Supplies failed.TASK_RES_INST_REQ');

Line 1851: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

1847: ELSIF pTASKNUM= TASK_RES_INST_REQ THEN
1848: IF MSC_CL_SUPPLY_ODS_LOAD.IS_SUPPLIES_LOAD_DONE THEN
1849: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1850: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_WIP_ODS_LOAD.LOAD_RES_INST_REQ');
1851: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1852: MSC_CL_WIP_ODS_LOAD.LOAD_RES_INST_REQ;
1853: ELSE
1854: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, 'Loading of Supplies failed.TASK_RES_INST_REQ');
1855: RAISE SUPPLIES_LOAD_FAIL;

Line 1859: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');

1855: RAISE SUPPLIES_LOAD_FAIL;
1856: END IF;
1857: ELSIF pTASKNUM= TASK_RESOURCE_SETUP THEN
1858: IF (v_apps_ver >= MSC_UTIL.G_APPS115) OR v_is_legacy_refresh THEN
1859: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1860: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_BOM_ODS_LOAD.LOAD_RESOURCE_SETUP');
1861: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1862: MSC_CL_BOM_ODS_LOAD.LOAD_RESOURCE_SETUP;
1863: END IF;

Line 1860: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_BOM_ODS_LOAD.LOAD_RESOURCE_SETUP');

1856: END IF;
1857: ELSIF pTASKNUM= TASK_RESOURCE_SETUP THEN
1858: IF (v_apps_ver >= MSC_UTIL.G_APPS115) OR v_is_legacy_refresh THEN
1859: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1860: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_BOM_ODS_LOAD.LOAD_RESOURCE_SETUP');
1861: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1862: MSC_CL_BOM_ODS_LOAD.LOAD_RESOURCE_SETUP;
1863: END IF;
1864: ELSIF pTASKNUM= TASK_SETUP_TRANSITION THEN

Line 1861: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

1857: ELSIF pTASKNUM= TASK_RESOURCE_SETUP THEN
1858: IF (v_apps_ver >= MSC_UTIL.G_APPS115) OR v_is_legacy_refresh THEN
1859: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1860: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_BOM_ODS_LOAD.LOAD_RESOURCE_SETUP');
1861: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1862: MSC_CL_BOM_ODS_LOAD.LOAD_RESOURCE_SETUP;
1863: END IF;
1864: ELSIF pTASKNUM= TASK_SETUP_TRANSITION THEN
1865: IF (v_apps_ver >= MSC_UTIL.G_APPS115) OR v_is_legacy_refresh THEN

Line 1866: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');

1862: MSC_CL_BOM_ODS_LOAD.LOAD_RESOURCE_SETUP;
1863: END IF;
1864: ELSIF pTASKNUM= TASK_SETUP_TRANSITION THEN
1865: IF (v_apps_ver >= MSC_UTIL.G_APPS115) OR v_is_legacy_refresh THEN
1866: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1867: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_BOM_ODS_LOAD.LOAD_SETUP_TRANSITION');
1868: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1869: MSC_CL_BOM_ODS_LOAD.LOAD_SETUP_TRANSITION;
1870: END IF;

Line 1867: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_BOM_ODS_LOAD.LOAD_SETUP_TRANSITION');

1863: END IF;
1864: ELSIF pTASKNUM= TASK_SETUP_TRANSITION THEN
1865: IF (v_apps_ver >= MSC_UTIL.G_APPS115) OR v_is_legacy_refresh THEN
1866: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1867: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_BOM_ODS_LOAD.LOAD_SETUP_TRANSITION');
1868: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1869: MSC_CL_BOM_ODS_LOAD.LOAD_SETUP_TRANSITION;
1870: END IF;
1871: ELSIF pTASKNUM= TASK_STD_OP_RESOURCES THEN

Line 1868: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

1864: ELSIF pTASKNUM= TASK_SETUP_TRANSITION THEN
1865: IF (v_apps_ver >= MSC_UTIL.G_APPS115) OR v_is_legacy_refresh THEN
1866: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1867: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_BOM_ODS_LOAD.LOAD_SETUP_TRANSITION');
1868: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1869: MSC_CL_BOM_ODS_LOAD.LOAD_SETUP_TRANSITION;
1870: END IF;
1871: ELSIF pTASKNUM= TASK_STD_OP_RESOURCES THEN
1872: IF (v_apps_ver >= MSC_UTIL.G_APPS115) OR v_is_legacy_refresh THEN

Line 1873: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');

1869: MSC_CL_BOM_ODS_LOAD.LOAD_SETUP_TRANSITION;
1870: END IF;
1871: ELSIF pTASKNUM= TASK_STD_OP_RESOURCES THEN
1872: IF (v_apps_ver >= MSC_UTIL.G_APPS115) OR v_is_legacy_refresh THEN
1873: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1874: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ROUTING_ODS_LOAD.LOAD_STD_OP_RESOURCES');
1875: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1876: MSC_CL_ROUTING_ODS_LOAD.LOAD_STD_OP_RESOURCES;
1877: END IF;

Line 1874: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ROUTING_ODS_LOAD.LOAD_STD_OP_RESOURCES');

1870: END IF;
1871: ELSIF pTASKNUM= TASK_STD_OP_RESOURCES THEN
1872: IF (v_apps_ver >= MSC_UTIL.G_APPS115) OR v_is_legacy_refresh THEN
1873: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1874: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ROUTING_ODS_LOAD.LOAD_STD_OP_RESOURCES');
1875: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1876: MSC_CL_ROUTING_ODS_LOAD.LOAD_STD_OP_RESOURCES;
1877: END IF;
1878: /* ds change end */

Line 1875: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

1871: ELSIF pTASKNUM= TASK_STD_OP_RESOURCES THEN
1872: IF (v_apps_ver >= MSC_UTIL.G_APPS115) OR v_is_legacy_refresh THEN
1873: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1874: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ROUTING_ODS_LOAD.LOAD_STD_OP_RESOURCES');
1875: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1876: MSC_CL_ROUTING_ODS_LOAD.LOAD_STD_OP_RESOURCES;
1877: END IF;
1878: /* ds change end */
1879: ELSIF pTASKNUM= TASK_SALES_CHANNEL THEN

Line 1880: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');

1876: MSC_CL_ROUTING_ODS_LOAD.LOAD_STD_OP_RESOURCES;
1877: END IF;
1878: /* ds change end */
1879: ELSIF pTASKNUM= TASK_SALES_CHANNEL THEN
1880: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1881: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_SALES_CHANNEL');
1882: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1883: -- LOG_MESSAGE(FND_MESSAGE.GET);
1884: MSC_CL_OTHER_ODS_LOAD.LOAD_SALES_CHANNEL;

Line 1881: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_SALES_CHANNEL');

1877: END IF;
1878: /* ds change end */
1879: ELSIF pTASKNUM= TASK_SALES_CHANNEL THEN
1880: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1881: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_SALES_CHANNEL');
1882: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1883: -- LOG_MESSAGE(FND_MESSAGE.GET);
1884: MSC_CL_OTHER_ODS_LOAD.LOAD_SALES_CHANNEL;
1885: ELSIF pTASKNUM= TASK_FISCAL_CALENDAR THEN

Line 1882: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

1878: /* ds change end */
1879: ELSIF pTASKNUM= TASK_SALES_CHANNEL THEN
1880: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1881: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_SALES_CHANNEL');
1882: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1883: -- LOG_MESSAGE(FND_MESSAGE.GET);
1884: MSC_CL_OTHER_ODS_LOAD.LOAD_SALES_CHANNEL;
1885: ELSIF pTASKNUM= TASK_FISCAL_CALENDAR THEN
1886: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');

Line 1883: -- LOG_MESSAGE(FND_MESSAGE.GET);

1879: ELSIF pTASKNUM= TASK_SALES_CHANNEL THEN
1880: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1881: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_SALES_CHANNEL');
1882: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1883: -- LOG_MESSAGE(FND_MESSAGE.GET);
1884: MSC_CL_OTHER_ODS_LOAD.LOAD_SALES_CHANNEL;
1885: ELSIF pTASKNUM= TASK_FISCAL_CALENDAR THEN
1886: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1887: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_FISCAL_CALENDAR');

Line 1886: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');

1882: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1883: -- LOG_MESSAGE(FND_MESSAGE.GET);
1884: MSC_CL_OTHER_ODS_LOAD.LOAD_SALES_CHANNEL;
1885: ELSIF pTASKNUM= TASK_FISCAL_CALENDAR THEN
1886: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1887: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_FISCAL_CALENDAR');
1888: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1889: -- LOG_MESSAGE(FND_MESSAGE.GET);
1890: MSC_CL_OTHER_ODS_LOAD.LOAD_FISCAL_CALENDAR;

Line 1887: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_FISCAL_CALENDAR');

1883: -- LOG_MESSAGE(FND_MESSAGE.GET);
1884: MSC_CL_OTHER_ODS_LOAD.LOAD_SALES_CHANNEL;
1885: ELSIF pTASKNUM= TASK_FISCAL_CALENDAR THEN
1886: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1887: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_FISCAL_CALENDAR');
1888: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1889: -- LOG_MESSAGE(FND_MESSAGE.GET);
1890: MSC_CL_OTHER_ODS_LOAD.LOAD_FISCAL_CALENDAR;
1891:

Line 1888: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

1884: MSC_CL_OTHER_ODS_LOAD.LOAD_SALES_CHANNEL;
1885: ELSIF pTASKNUM= TASK_FISCAL_CALENDAR THEN
1886: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1887: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_FISCAL_CALENDAR');
1888: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1889: -- LOG_MESSAGE(FND_MESSAGE.GET);
1890: MSC_CL_OTHER_ODS_LOAD.LOAD_FISCAL_CALENDAR;
1891:
1892: ELSIF pTASKNUM= TASK_PAYBACK_DEMAND_SUPPLY THEN

Line 1889: -- LOG_MESSAGE(FND_MESSAGE.GET);

1885: ELSIF pTASKNUM= TASK_FISCAL_CALENDAR THEN
1886: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1887: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_FISCAL_CALENDAR');
1888: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1889: -- LOG_MESSAGE(FND_MESSAGE.GET);
1890: MSC_CL_OTHER_ODS_LOAD.LOAD_FISCAL_CALENDAR;
1891:
1892: ELSIF pTASKNUM= TASK_PAYBACK_DEMAND_SUPPLY THEN
1893: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');

Line 1893: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');

1889: -- LOG_MESSAGE(FND_MESSAGE.GET);
1890: MSC_CL_OTHER_ODS_LOAD.LOAD_FISCAL_CALENDAR;
1891:
1892: ELSIF pTASKNUM= TASK_PAYBACK_DEMAND_SUPPLY THEN
1893: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1894: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LOAD_PAYBACK_DEMANDS');
1895: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS,FND_MESSAGE.GET);
1896: MSC_CL_DEMAND_ODS_LOAD.LOAD_PAYBACK_DEMANDS;
1897:

Line 1894: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LOAD_PAYBACK_DEMANDS');

1890: MSC_CL_OTHER_ODS_LOAD.LOAD_FISCAL_CALENDAR;
1891:
1892: ELSIF pTASKNUM= TASK_PAYBACK_DEMAND_SUPPLY THEN
1893: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1894: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LOAD_PAYBACK_DEMANDS');
1895: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS,FND_MESSAGE.GET);
1896: MSC_CL_DEMAND_ODS_LOAD.LOAD_PAYBACK_DEMANDS;
1897:
1898: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');

Line 1895: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS,FND_MESSAGE.GET);

1891:
1892: ELSIF pTASKNUM= TASK_PAYBACK_DEMAND_SUPPLY THEN
1893: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1894: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LOAD_PAYBACK_DEMANDS');
1895: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS,FND_MESSAGE.GET);
1896: MSC_CL_DEMAND_ODS_LOAD.LOAD_PAYBACK_DEMANDS;
1897:
1898: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1899: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SUPPLY_ODS_LOAD.LOAD_PAYBACK_SUPPLIES');

Line 1898: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');

1894: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LOAD_PAYBACK_DEMANDS');
1895: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS,FND_MESSAGE.GET);
1896: MSC_CL_DEMAND_ODS_LOAD.LOAD_PAYBACK_DEMANDS;
1897:
1898: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1899: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SUPPLY_ODS_LOAD.LOAD_PAYBACK_SUPPLIES');
1900: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS,FND_MESSAGE.GET);
1901: MSC_CL_SUPPLY_ODS_LOAD.LOAD_PAYBACK_SUPPLIES;
1902:

Line 1899: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SUPPLY_ODS_LOAD.LOAD_PAYBACK_SUPPLIES');

1895: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS,FND_MESSAGE.GET);
1896: MSC_CL_DEMAND_ODS_LOAD.LOAD_PAYBACK_DEMANDS;
1897:
1898: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1899: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SUPPLY_ODS_LOAD.LOAD_PAYBACK_SUPPLIES');
1900: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS,FND_MESSAGE.GET);
1901: MSC_CL_SUPPLY_ODS_LOAD.LOAD_PAYBACK_SUPPLIES;
1902:
1903: ELSIF pTASKNUM= TASK_CURRENCY_CONVERSION THEN ---- for bug # 6469722

Line 1900: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS,FND_MESSAGE.GET);

1896: MSC_CL_DEMAND_ODS_LOAD.LOAD_PAYBACK_DEMANDS;
1897:
1898: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1899: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SUPPLY_ODS_LOAD.LOAD_PAYBACK_SUPPLIES');
1900: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS,FND_MESSAGE.GET);
1901: MSC_CL_SUPPLY_ODS_LOAD.LOAD_PAYBACK_SUPPLIES;
1902:
1903: ELSIF pTASKNUM= TASK_CURRENCY_CONVERSION THEN ---- for bug # 6469722
1904: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');

Line 1904: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');

1900: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS,FND_MESSAGE.GET);
1901: MSC_CL_SUPPLY_ODS_LOAD.LOAD_PAYBACK_SUPPLIES;
1902:
1903: ELSIF pTASKNUM= TASK_CURRENCY_CONVERSION THEN ---- for bug # 6469722
1904: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1905: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_CURRENCY_CONVERSION');
1906: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1907: IF (MSC_CL_OTHER_PULL.G_MSC_HUB_CURR_CODE IS NOT NULL) AND (v_apps_ver >= MSC_UTIL.G_APPS115) THEN
1908: MSC_CL_OTHER_ODS_LOAD.LOAD_CURRENCY_CONVERSION;

Line 1905: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_CURRENCY_CONVERSION');

1901: MSC_CL_SUPPLY_ODS_LOAD.LOAD_PAYBACK_SUPPLIES;
1902:
1903: ELSIF pTASKNUM= TASK_CURRENCY_CONVERSION THEN ---- for bug # 6469722
1904: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1905: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_CURRENCY_CONVERSION');
1906: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1907: IF (MSC_CL_OTHER_PULL.G_MSC_HUB_CURR_CODE IS NOT NULL) AND (v_apps_ver >= MSC_UTIL.G_APPS115) THEN
1908: MSC_CL_OTHER_ODS_LOAD.LOAD_CURRENCY_CONVERSION;
1909: ELSE

Line 1906: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

1902:
1903: ELSIF pTASKNUM= TASK_CURRENCY_CONVERSION THEN ---- for bug # 6469722
1904: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1905: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_CURRENCY_CONVERSION');
1906: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1907: IF (MSC_CL_OTHER_PULL.G_MSC_HUB_CURR_CODE IS NOT NULL) AND (v_apps_ver >= MSC_UTIL.G_APPS115) THEN
1908: MSC_CL_OTHER_ODS_LOAD.LOAD_CURRENCY_CONVERSION;
1909: ELSE
1910: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, 'Currency Data is not collected as MSC:Planning Hub Currency Code Profile is NULL or source is not 11i or greater.');

Line 1914: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');

1910: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, 'Currency Data is not collected as MSC:Planning Hub Currency Code Profile is NULL or source is not 11i or greater.');
1911: END IF;
1912:
1913: ELSIF pTASKNUM= TASK_DELIVERY_DETAILS THEN ---- for bug # 6730983
1914: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1915: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_DELIVERY_DETAILS');
1916: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1917: -- LOG_MESSAGE(FND_MESSAGE.GET);
1918: MSC_CL_OTHER_ODS_LOAD.LOAD_DELIVERY_DETAILS;

Line 1915: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_DELIVERY_DETAILS');

1911: END IF;
1912:
1913: ELSIF pTASKNUM= TASK_DELIVERY_DETAILS THEN ---- for bug # 6730983
1914: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1915: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_DELIVERY_DETAILS');
1916: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1917: -- LOG_MESSAGE(FND_MESSAGE.GET);
1918: MSC_CL_OTHER_ODS_LOAD.LOAD_DELIVERY_DETAILS;
1919:

Line 1916: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

1912:
1913: ELSIF pTASKNUM= TASK_DELIVERY_DETAILS THEN ---- for bug # 6730983
1914: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1915: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_DELIVERY_DETAILS');
1916: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1917: -- LOG_MESSAGE(FND_MESSAGE.GET);
1918: MSC_CL_OTHER_ODS_LOAD.LOAD_DELIVERY_DETAILS;
1919:
1920: ELSIF pTASKNUM= TASK_IRO_DEMAND THEN -- Changed For bug 5909379 SRP Additions

Line 1917: -- LOG_MESSAGE(FND_MESSAGE.GET);

1913: ELSIF pTASKNUM= TASK_DELIVERY_DETAILS THEN ---- for bug # 6730983
1914: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1915: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_DELIVERY_DETAILS');
1916: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1917: -- LOG_MESSAGE(FND_MESSAGE.GET);
1918: MSC_CL_OTHER_ODS_LOAD.LOAD_DELIVERY_DETAILS;
1919:
1920: ELSIF pTASKNUM= TASK_IRO_DEMAND THEN -- Changed For bug 5909379 SRP Additions
1921:

Line 1925: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');

1921:
1922:
1923:
1924: IF MSC_CL_SUPPLY_ODS_LOAD.IS_SUPPLIES_LOAD_DONE THEN
1925: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1926: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_RPO_ODS_LOAD.LOAD_IRO_DEMAND;');
1927: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1928: -- LOG_MESSAGE(FND_MESSAGE.GET);
1929: MSC_CL_RPO_ODS_LOAD.LOAD_IRO_DEMAND;

Line 1926: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_RPO_ODS_LOAD.LOAD_IRO_DEMAND;');

1922:
1923:
1924: IF MSC_CL_SUPPLY_ODS_LOAD.IS_SUPPLIES_LOAD_DONE THEN
1925: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1926: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_RPO_ODS_LOAD.LOAD_IRO_DEMAND;');
1927: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1928: -- LOG_MESSAGE(FND_MESSAGE.GET);
1929: MSC_CL_RPO_ODS_LOAD.LOAD_IRO_DEMAND;
1930: END IF;

Line 1927: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

1923:
1924: IF MSC_CL_SUPPLY_ODS_LOAD.IS_SUPPLIES_LOAD_DONE THEN
1925: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1926: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_RPO_ODS_LOAD.LOAD_IRO_DEMAND;');
1927: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1928: -- LOG_MESSAGE(FND_MESSAGE.GET);
1929: MSC_CL_RPO_ODS_LOAD.LOAD_IRO_DEMAND;
1930: END IF;
1931:

Line 1928: -- LOG_MESSAGE(FND_MESSAGE.GET);

1924: IF MSC_CL_SUPPLY_ODS_LOAD.IS_SUPPLIES_LOAD_DONE THEN
1925: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1926: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_RPO_ODS_LOAD.LOAD_IRO_DEMAND;');
1927: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1928: -- LOG_MESSAGE(FND_MESSAGE.GET);
1929: MSC_CL_RPO_ODS_LOAD.LOAD_IRO_DEMAND;
1930: END IF;
1931:
1932:

Line 1939: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');

1935:
1936:
1937:
1938: IF MSC_CL_SUPPLY_ODS_LOAD.IS_SUPPLIES_LOAD_DONE THEN
1939: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1940: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_RPO_ODS_LOAD.LOAD_ERO_DEMAND;');
1941: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1942: --LOG_MESSAGE(FND_MESSAGE.GET);
1943: MSC_CL_RPO_ODS_LOAD.LOAD_ERO_DEMAND;

Line 1940: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_RPO_ODS_LOAD.LOAD_ERO_DEMAND;');

1936:
1937:
1938: IF MSC_CL_SUPPLY_ODS_LOAD.IS_SUPPLIES_LOAD_DONE THEN
1939: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1940: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_RPO_ODS_LOAD.LOAD_ERO_DEMAND;');
1941: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1942: --LOG_MESSAGE(FND_MESSAGE.GET);
1943: MSC_CL_RPO_ODS_LOAD.LOAD_ERO_DEMAND;
1944: END IF;

Line 1941: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

1937:
1938: IF MSC_CL_SUPPLY_ODS_LOAD.IS_SUPPLIES_LOAD_DONE THEN
1939: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1940: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_RPO_ODS_LOAD.LOAD_ERO_DEMAND;');
1941: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1942: --LOG_MESSAGE(FND_MESSAGE.GET);
1943: MSC_CL_RPO_ODS_LOAD.LOAD_ERO_DEMAND;
1944: END IF;
1945:

Line 1942: --LOG_MESSAGE(FND_MESSAGE.GET);

1938: IF MSC_CL_SUPPLY_ODS_LOAD.IS_SUPPLIES_LOAD_DONE THEN
1939: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1940: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_RPO_ODS_LOAD.LOAD_ERO_DEMAND;');
1941: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1942: --LOG_MESSAGE(FND_MESSAGE.GET);
1943: MSC_CL_RPO_ODS_LOAD.LOAD_ERO_DEMAND;
1944: END IF;
1945:
1946: ELSE

Line 1956: FND_MESSAGE.SET_NAME('MSC', 'MSC_ELAPSED_TIME');

1952: -- ======== If no EXCEPTION occurs, then returns with status = OK =========
1953:
1954: pSTATUS := OK;
1955:
1956: FND_MESSAGE.SET_NAME('MSC', 'MSC_ELAPSED_TIME');
1957: FND_MESSAGE.SET_TOKEN('ELAPSED_TIME',
1958: TO_CHAR(CEIL((SYSDATE- lv_task_start_time)*14400.0)/10));
1959: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1960:

Line 1957: FND_MESSAGE.SET_TOKEN('ELAPSED_TIME',

1953:
1954: pSTATUS := OK;
1955:
1956: FND_MESSAGE.SET_NAME('MSC', 'MSC_ELAPSED_TIME');
1957: FND_MESSAGE.SET_TOKEN('ELAPSED_TIME',
1958: TO_CHAR(CEIL((SYSDATE- lv_task_start_time)*14400.0)/10));
1959: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1960:
1961: msc_util.print_top_wait(CEIL((SYSDATE- lv_task_start_time)*14400.0)/10);

Line 1959: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

1955:
1956: FND_MESSAGE.SET_NAME('MSC', 'MSC_ELAPSED_TIME');
1957: FND_MESSAGE.SET_TOKEN('ELAPSED_TIME',
1958: TO_CHAR(CEIL((SYSDATE- lv_task_start_time)*14400.0)/10));
1959: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1960:
1961: msc_util.print_top_wait(CEIL((SYSDATE- lv_task_start_time)*14400.0)/10);
1962: msc_util.print_cum_stat(CEIL((SYSDATE- lv_task_start_time)*14400.0)/10);
1963: msc_util.print_bad_sqls(CEIL((SYSDATE- lv_task_start_time)*14400.0)/10);

Line 2065: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');

2061: -- ====== Execute the partial task according to its task number ==========
2062:
2063: IF pTASKNUM= PTASK_SUPPLIER_CAPACITY THEN
2064: IF(prec.item_flag=MSC_UTIL.SYS_NO) THEN
2065: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2066: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ITEM_ODS_LOAD.LOAD_SUPPLIER_CAPACITY');
2067: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2068: MSC_CL_ITEM_ODS_LOAD.LOAD_SUPPLIER_CAPACITY;
2069: MSC_CL_SETUP_ODS_LOAD.CLEAN_LIAB_AGREEMENT ;

Line 2066: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ITEM_ODS_LOAD.LOAD_SUPPLIER_CAPACITY');

2062:
2063: IF pTASKNUM= PTASK_SUPPLIER_CAPACITY THEN
2064: IF(prec.item_flag=MSC_UTIL.SYS_NO) THEN
2065: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2066: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ITEM_ODS_LOAD.LOAD_SUPPLIER_CAPACITY');
2067: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2068: MSC_CL_ITEM_ODS_LOAD.LOAD_SUPPLIER_CAPACITY;
2069: MSC_CL_SETUP_ODS_LOAD.CLEAN_LIAB_AGREEMENT ;
2070: END IF ;

Line 2067: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

2063: IF pTASKNUM= PTASK_SUPPLIER_CAPACITY THEN
2064: IF(prec.item_flag=MSC_UTIL.SYS_NO) THEN
2065: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2066: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ITEM_ODS_LOAD.LOAD_SUPPLIER_CAPACITY');
2067: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2068: MSC_CL_ITEM_ODS_LOAD.LOAD_SUPPLIER_CAPACITY;
2069: MSC_CL_SETUP_ODS_LOAD.CLEAN_LIAB_AGREEMENT ;
2070: END IF ;
2071:

Line 2074: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');

2070: END IF ;
2071:
2072: ELSIF pTASKNUM= PTASK_ITEM THEN
2073:
2074: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2075: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ITEM_ODS_LOAD.LOAD_ITEM');
2076: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2077: MSC_CL_ITEM_ODS_LOAD.LOAD_ITEM;
2078:

Line 2075: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ITEM_ODS_LOAD.LOAD_ITEM');

2071:
2072: ELSIF pTASKNUM= PTASK_ITEM THEN
2073:
2074: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2075: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ITEM_ODS_LOAD.LOAD_ITEM');
2076: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2077: MSC_CL_ITEM_ODS_LOAD.LOAD_ITEM;
2078:
2079: /* for bug 5233688 */

Line 2076: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

2072: ELSIF pTASKNUM= PTASK_ITEM THEN
2073:
2074: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2075: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ITEM_ODS_LOAD.LOAD_ITEM');
2076: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2077: MSC_CL_ITEM_ODS_LOAD.LOAD_ITEM;
2078:
2079: /* for bug 5233688 */
2080: IF(prec.app_supp_cap_flag=MSC_UTIL.SYS_YES or prec.app_supp_cap_flag=MSC_UTIL.ASL_YES_RETAIN_CP) THEN

Line 2081: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');

2077: MSC_CL_ITEM_ODS_LOAD.LOAD_ITEM;
2078:
2079: /* for bug 5233688 */
2080: IF(prec.app_supp_cap_flag=MSC_UTIL.SYS_YES or prec.app_supp_cap_flag=MSC_UTIL.ASL_YES_RETAIN_CP) THEN
2081: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2082: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ITEM_ODS_LOAD.LOAD_SUPPLIER_CAPACITY');
2083: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2084: MSC_CL_ITEM_ODS_LOAD.LOAD_SUPPLIER_CAPACITY;
2085: MSC_CL_SETUP_ODS_LOAD.CLEAN_LIAB_AGREEMENT ;

Line 2082: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ITEM_ODS_LOAD.LOAD_SUPPLIER_CAPACITY');

2078:
2079: /* for bug 5233688 */
2080: IF(prec.app_supp_cap_flag=MSC_UTIL.SYS_YES or prec.app_supp_cap_flag=MSC_UTIL.ASL_YES_RETAIN_CP) THEN
2081: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2082: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ITEM_ODS_LOAD.LOAD_SUPPLIER_CAPACITY');
2083: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2084: MSC_CL_ITEM_ODS_LOAD.LOAD_SUPPLIER_CAPACITY;
2085: MSC_CL_SETUP_ODS_LOAD.CLEAN_LIAB_AGREEMENT ;
2086: END IF ;

Line 2083: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

2079: /* for bug 5233688 */
2080: IF(prec.app_supp_cap_flag=MSC_UTIL.SYS_YES or prec.app_supp_cap_flag=MSC_UTIL.ASL_YES_RETAIN_CP) THEN
2081: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2082: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ITEM_ODS_LOAD.LOAD_SUPPLIER_CAPACITY');
2083: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2084: MSC_CL_ITEM_ODS_LOAD.LOAD_SUPPLIER_CAPACITY;
2085: MSC_CL_SETUP_ODS_LOAD.CLEAN_LIAB_AGREEMENT ;
2086: END IF ;
2087:

Line 2090: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');

2086: END IF ;
2087:
2088: ELSIF pTASKNUM= PTASK_ABC_CLASSES THEN
2089:
2090: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2091: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ITEM_ODS_LOAD.LOAD_ABC_CLASSES');
2092: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2093: MSC_CL_ITEM_ODS_LOAD.LOAD_ABC_CLASSES;
2094:

Line 2091: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ITEM_ODS_LOAD.LOAD_ABC_CLASSES');

2087:
2088: ELSIF pTASKNUM= PTASK_ABC_CLASSES THEN
2089:
2090: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2091: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ITEM_ODS_LOAD.LOAD_ABC_CLASSES');
2092: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2093: MSC_CL_ITEM_ODS_LOAD.LOAD_ABC_CLASSES;
2094:
2095: ELSIF pTASKNUM= PTASK_CATEGORY_ITEM THEN

Line 2092: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

2088: ELSIF pTASKNUM= PTASK_ABC_CLASSES THEN
2089:
2090: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2091: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ITEM_ODS_LOAD.LOAD_ABC_CLASSES');
2092: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2093: MSC_CL_ITEM_ODS_LOAD.LOAD_ABC_CLASSES;
2094:
2095: ELSIF pTASKNUM= PTASK_CATEGORY_ITEM THEN
2096:

Line 2097: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');

2093: MSC_CL_ITEM_ODS_LOAD.LOAD_ABC_CLASSES;
2094:
2095: ELSIF pTASKNUM= PTASK_CATEGORY_ITEM THEN
2096:
2097: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2098: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ITEM_ODS_LOAD.LOAD_CATEGORY');
2099: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2100: MSC_CL_ITEM_ODS_LOAD.LOAD_CATEGORY;
2101:

Line 2098: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ITEM_ODS_LOAD.LOAD_CATEGORY');

2094:
2095: ELSIF pTASKNUM= PTASK_CATEGORY_ITEM THEN
2096:
2097: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2098: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ITEM_ODS_LOAD.LOAD_CATEGORY');
2099: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2100: MSC_CL_ITEM_ODS_LOAD.LOAD_CATEGORY;
2101:
2102: ELSIF pTASKNUM= PTASK_TRADING_PARTNER THEN

Line 2099: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

2095: ELSIF pTASKNUM= PTASK_CATEGORY_ITEM THEN
2096:
2097: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2098: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ITEM_ODS_LOAD.LOAD_CATEGORY');
2099: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2100: MSC_CL_ITEM_ODS_LOAD.LOAD_CATEGORY;
2101:
2102: ELSIF pTASKNUM= PTASK_TRADING_PARTNER THEN
2103:

Line 2104: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');

2100: MSC_CL_ITEM_ODS_LOAD.LOAD_CATEGORY;
2101:
2102: ELSIF pTASKNUM= PTASK_TRADING_PARTNER THEN
2103:
2104: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2105: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SETUP_ODS_LOAD.LOAD_TRADING_PARTNER');
2106: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2107: MSC_CL_SETUP_ODS_LOAD.LOAD_TRADING_PARTNER;
2108:

Line 2105: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SETUP_ODS_LOAD.LOAD_TRADING_PARTNER');

2101:
2102: ELSIF pTASKNUM= PTASK_TRADING_PARTNER THEN
2103:
2104: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2105: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SETUP_ODS_LOAD.LOAD_TRADING_PARTNER');
2106: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2107: MSC_CL_SETUP_ODS_LOAD.LOAD_TRADING_PARTNER;
2108:
2109: ELSIF pTASKNUM= PTASK_BOM_COMPONENTS THEN

Line 2106: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

2102: ELSIF pTASKNUM= PTASK_TRADING_PARTNER THEN
2103:
2104: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2105: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SETUP_ODS_LOAD.LOAD_TRADING_PARTNER');
2106: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2107: MSC_CL_SETUP_ODS_LOAD.LOAD_TRADING_PARTNER;
2108:
2109: ELSIF pTASKNUM= PTASK_BOM_COMPONENTS THEN
2110:

Line 2111: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');

2107: MSC_CL_SETUP_ODS_LOAD.LOAD_TRADING_PARTNER;
2108:
2109: ELSIF pTASKNUM= PTASK_BOM_COMPONENTS THEN
2110:
2111: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2112: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_BOM_ODS_LOAD.LOAD_BOM_COMPONENTS');
2113: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2114: MSC_CL_BOM_ODS_LOAD.LOAD_BOM_COMPONENTS;
2115:

Line 2112: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_BOM_ODS_LOAD.LOAD_BOM_COMPONENTS');

2108:
2109: ELSIF pTASKNUM= PTASK_BOM_COMPONENTS THEN
2110:
2111: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2112: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_BOM_ODS_LOAD.LOAD_BOM_COMPONENTS');
2113: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2114: MSC_CL_BOM_ODS_LOAD.LOAD_BOM_COMPONENTS;
2115:
2116: ELSIF pTASKNUM= PTASK_BOM THEN

Line 2113: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

2109: ELSIF pTASKNUM= PTASK_BOM_COMPONENTS THEN
2110:
2111: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2112: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_BOM_ODS_LOAD.LOAD_BOM_COMPONENTS');
2113: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2114: MSC_CL_BOM_ODS_LOAD.LOAD_BOM_COMPONENTS;
2115:
2116: ELSIF pTASKNUM= PTASK_BOM THEN
2117:

Line 2118: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');

2114: MSC_CL_BOM_ODS_LOAD.LOAD_BOM_COMPONENTS;
2115:
2116: ELSIF pTASKNUM= PTASK_BOM THEN
2117:
2118: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2119: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_BOM_ODS_LOAD.LOAD_BOM');
2120: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2121: MSC_CL_BOM_ODS_LOAD.LOAD_BOM;
2122:

Line 2119: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_BOM_ODS_LOAD.LOAD_BOM');

2115:
2116: ELSIF pTASKNUM= PTASK_BOM THEN
2117:
2118: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2119: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_BOM_ODS_LOAD.LOAD_BOM');
2120: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2121: MSC_CL_BOM_ODS_LOAD.LOAD_BOM;
2122:
2123: ELSIF pTASKNUM= PTASK_COMPONENT_SUBSTITUTE THEN

Line 2120: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

2116: ELSIF pTASKNUM= PTASK_BOM THEN
2117:
2118: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2119: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_BOM_ODS_LOAD.LOAD_BOM');
2120: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2121: MSC_CL_BOM_ODS_LOAD.LOAD_BOM;
2122:
2123: ELSIF pTASKNUM= PTASK_COMPONENT_SUBSTITUTE THEN
2124:

Line 2125: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');

2121: MSC_CL_BOM_ODS_LOAD.LOAD_BOM;
2122:
2123: ELSIF pTASKNUM= PTASK_COMPONENT_SUBSTITUTE THEN
2124:
2125: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2126: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_BOM_ODS_LOAD.LOAD_COMPONENT_SUBSTITUTE');
2127: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2128: MSC_CL_BOM_ODS_LOAD.LOAD_COMPONENT_SUBSTITUTE;
2129:

Line 2126: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_BOM_ODS_LOAD.LOAD_COMPONENT_SUBSTITUTE');

2122:
2123: ELSIF pTASKNUM= PTASK_COMPONENT_SUBSTITUTE THEN
2124:
2125: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2126: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_BOM_ODS_LOAD.LOAD_COMPONENT_SUBSTITUTE');
2127: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2128: MSC_CL_BOM_ODS_LOAD.LOAD_COMPONENT_SUBSTITUTE;
2129:
2130: ELSIF pTASKNUM= PTASK_ROUTING THEN

Line 2127: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

2123: ELSIF pTASKNUM= PTASK_COMPONENT_SUBSTITUTE THEN
2124:
2125: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2126: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_BOM_ODS_LOAD.LOAD_COMPONENT_SUBSTITUTE');
2127: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2128: MSC_CL_BOM_ODS_LOAD.LOAD_COMPONENT_SUBSTITUTE;
2129:
2130: ELSIF pTASKNUM= PTASK_ROUTING THEN
2131:

Line 2132: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');

2128: MSC_CL_BOM_ODS_LOAD.LOAD_COMPONENT_SUBSTITUTE;
2129:
2130: ELSIF pTASKNUM= PTASK_ROUTING THEN
2131:
2132: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2133: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ROUTING_ODS_LOAD.LOAD_ROUTING');
2134: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2135: MSC_CL_ROUTING_ODS_LOAD.LOAD_ROUTING;
2136:

Line 2133: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ROUTING_ODS_LOAD.LOAD_ROUTING');

2129:
2130: ELSIF pTASKNUM= PTASK_ROUTING THEN
2131:
2132: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2133: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ROUTING_ODS_LOAD.LOAD_ROUTING');
2134: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2135: MSC_CL_ROUTING_ODS_LOAD.LOAD_ROUTING;
2136:
2137: ELSIF pTASKNUM= PTASK_ROUTING_OPERATIONS THEN

Line 2134: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

2130: ELSIF pTASKNUM= PTASK_ROUTING THEN
2131:
2132: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2133: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ROUTING_ODS_LOAD.LOAD_ROUTING');
2134: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2135: MSC_CL_ROUTING_ODS_LOAD.LOAD_ROUTING;
2136:
2137: ELSIF pTASKNUM= PTASK_ROUTING_OPERATIONS THEN
2138:

Line 2139: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');

2135: MSC_CL_ROUTING_ODS_LOAD.LOAD_ROUTING;
2136:
2137: ELSIF pTASKNUM= PTASK_ROUTING_OPERATIONS THEN
2138:
2139: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2140: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ROUTING_ODS_LOAD.LOAD_ROUTING_OPERATIONS');
2141: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2142: MSC_CL_ROUTING_ODS_LOAD.LOAD_ROUTING_OPERATIONS;
2143:

Line 2140: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ROUTING_ODS_LOAD.LOAD_ROUTING_OPERATIONS');

2136:
2137: ELSIF pTASKNUM= PTASK_ROUTING_OPERATIONS THEN
2138:
2139: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2140: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ROUTING_ODS_LOAD.LOAD_ROUTING_OPERATIONS');
2141: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2142: MSC_CL_ROUTING_ODS_LOAD.LOAD_ROUTING_OPERATIONS;
2143:
2144: ELSIF pTASKNUM= PTASK_OPERATION_RESOURCES THEN

Line 2141: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

2137: ELSIF pTASKNUM= PTASK_ROUTING_OPERATIONS THEN
2138:
2139: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2140: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ROUTING_ODS_LOAD.LOAD_ROUTING_OPERATIONS');
2141: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2142: MSC_CL_ROUTING_ODS_LOAD.LOAD_ROUTING_OPERATIONS;
2143:
2144: ELSIF pTASKNUM= PTASK_OPERATION_RESOURCES THEN
2145:

Line 2146: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');

2142: MSC_CL_ROUTING_ODS_LOAD.LOAD_ROUTING_OPERATIONS;
2143:
2144: ELSIF pTASKNUM= PTASK_OPERATION_RESOURCES THEN
2145:
2146: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2147: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ROUTING_ODS_LOAD.LOAD_OPERATION_RESOURCES');
2148: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2149: MSC_CL_ROUTING_ODS_LOAD.LOAD_OPERATION_RESOURCES;
2150:

Line 2147: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ROUTING_ODS_LOAD.LOAD_OPERATION_RESOURCES');

2143:
2144: ELSIF pTASKNUM= PTASK_OPERATION_RESOURCES THEN
2145:
2146: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2147: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ROUTING_ODS_LOAD.LOAD_OPERATION_RESOURCES');
2148: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2149: MSC_CL_ROUTING_ODS_LOAD.LOAD_OPERATION_RESOURCES;
2150:
2151: ELSIF pTASKNUM= PTASK_RESOURCE THEN

Line 2148: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

2144: ELSIF pTASKNUM= PTASK_OPERATION_RESOURCES THEN
2145:
2146: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2147: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ROUTING_ODS_LOAD.LOAD_OPERATION_RESOURCES');
2148: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2149: MSC_CL_ROUTING_ODS_LOAD.LOAD_OPERATION_RESOURCES;
2150:
2151: ELSIF pTASKNUM= PTASK_RESOURCE THEN
2152:

Line 2153: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');

2149: MSC_CL_ROUTING_ODS_LOAD.LOAD_OPERATION_RESOURCES;
2150:
2151: ELSIF pTASKNUM= PTASK_RESOURCE THEN
2152:
2153: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2154: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'LOAD_RESOURCE');
2155: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2156: -- LOAD_RESOURCE;
2157:

Line 2154: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'LOAD_RESOURCE');

2150:
2151: ELSIF pTASKNUM= PTASK_RESOURCE THEN
2152:
2153: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2154: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'LOAD_RESOURCE');
2155: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2156: -- LOAD_RESOURCE;
2157:
2158:

Line 2155: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

2151: ELSIF pTASKNUM= PTASK_RESOURCE THEN
2152:
2153: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2154: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'LOAD_RESOURCE');
2155: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2156: -- LOAD_RESOURCE;
2157:
2158:
2159: -- BUG # 3020614

Line 2169: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');

2165: end if;
2166:
2167: ELSIF pTASKNUM= PTASK_OP_RESOURCE_SEQ THEN
2168:
2169: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2170: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ROUTING_ODS_LOAD.LOAD_OP_RESOURCE_SEQ');
2171: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2172: MSC_CL_ROUTING_ODS_LOAD.LOAD_OP_RESOURCE_SEQ;
2173:

Line 2170: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ROUTING_ODS_LOAD.LOAD_OP_RESOURCE_SEQ');

2166:
2167: ELSIF pTASKNUM= PTASK_OP_RESOURCE_SEQ THEN
2168:
2169: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2170: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ROUTING_ODS_LOAD.LOAD_OP_RESOURCE_SEQ');
2171: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2172: MSC_CL_ROUTING_ODS_LOAD.LOAD_OP_RESOURCE_SEQ;
2173:
2174: ELSIF pTASKNUM= PTASK_PROCESS_EFFECTIVITY THEN

Line 2171: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

2167: ELSIF pTASKNUM= PTASK_OP_RESOURCE_SEQ THEN
2168:
2169: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2170: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ROUTING_ODS_LOAD.LOAD_OP_RESOURCE_SEQ');
2171: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2172: MSC_CL_ROUTING_ODS_LOAD.LOAD_OP_RESOURCE_SEQ;
2173:
2174: ELSIF pTASKNUM= PTASK_PROCESS_EFFECTIVITY THEN
2175:

Line 2176: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');

2172: MSC_CL_ROUTING_ODS_LOAD.LOAD_OP_RESOURCE_SEQ;
2173:
2174: ELSIF pTASKNUM= PTASK_PROCESS_EFFECTIVITY THEN
2175:
2176: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2177: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_BOM_ODS_LOAD.LOAD_PROCESS_EFFECTIVITY');
2178: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2179: MSC_CL_BOM_ODS_LOAD.LOAD_PROCESS_EFFECTIVITY;
2180: -- Needs to be REVIEWED

Line 2177: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_BOM_ODS_LOAD.LOAD_PROCESS_EFFECTIVITY');

2173:
2174: ELSIF pTASKNUM= PTASK_PROCESS_EFFECTIVITY THEN
2175:
2176: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2177: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_BOM_ODS_LOAD.LOAD_PROCESS_EFFECTIVITY');
2178: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2179: MSC_CL_BOM_ODS_LOAD.LOAD_PROCESS_EFFECTIVITY;
2180: -- Needs to be REVIEWED
2181:

Line 2178: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

2174: ELSIF pTASKNUM= PTASK_PROCESS_EFFECTIVITY THEN
2175:
2176: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2177: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_BOM_ODS_LOAD.LOAD_PROCESS_EFFECTIVITY');
2178: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2179: MSC_CL_BOM_ODS_LOAD.LOAD_PROCESS_EFFECTIVITY;
2180: -- Needs to be REVIEWED
2181:
2182: ELSIF pTASKNUM= PTASK_OPERATION_COMPONENTS THEN

Line 2184: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');

2180: -- Needs to be REVIEWED
2181:
2182: ELSIF pTASKNUM= PTASK_OPERATION_COMPONENTS THEN
2183:
2184: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2185: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ROUTING_ODS_LOAD.LOAD_OPERATION_COMPONENTS');
2186: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2187: MSC_CL_ROUTING_ODS_LOAD.LOAD_OPERATION_COMPONENTS;
2188:

Line 2185: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ROUTING_ODS_LOAD.LOAD_OPERATION_COMPONENTS');

2181:
2182: ELSIF pTASKNUM= PTASK_OPERATION_COMPONENTS THEN
2183:
2184: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2185: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ROUTING_ODS_LOAD.LOAD_OPERATION_COMPONENTS');
2186: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2187: MSC_CL_ROUTING_ODS_LOAD.LOAD_OPERATION_COMPONENTS;
2188:
2189: ELSIF pTASKNUM= PTASK_OPERATION_NETWORKS THEN

Line 2186: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

2182: ELSIF pTASKNUM= PTASK_OPERATION_COMPONENTS THEN
2183:
2184: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2185: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ROUTING_ODS_LOAD.LOAD_OPERATION_COMPONENTS');
2186: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2187: MSC_CL_ROUTING_ODS_LOAD.LOAD_OPERATION_COMPONENTS;
2188:
2189: ELSIF pTASKNUM= PTASK_OPERATION_NETWORKS THEN
2190:

Line 2191: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');

2187: MSC_CL_ROUTING_ODS_LOAD.LOAD_OPERATION_COMPONENTS;
2188:
2189: ELSIF pTASKNUM= PTASK_OPERATION_NETWORKS THEN
2190:
2191: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2192: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ROUTING_ODS_LOAD.LOAD_OPERATION_NETWORKS');
2193: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2194: MSC_CL_ROUTING_ODS_LOAD.LOAD_OPERATION_NETWORKS;
2195:

Line 2192: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ROUTING_ODS_LOAD.LOAD_OPERATION_NETWORKS');

2188:
2189: ELSIF pTASKNUM= PTASK_OPERATION_NETWORKS THEN
2190:
2191: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2192: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ROUTING_ODS_LOAD.LOAD_OPERATION_NETWORKS');
2193: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2194: MSC_CL_ROUTING_ODS_LOAD.LOAD_OPERATION_NETWORKS;
2195:
2196: ELSIF pTASKNUM= PTASK_HARD_RESERVATION THEN

Line 2193: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

2189: ELSIF pTASKNUM= PTASK_OPERATION_NETWORKS THEN
2190:
2191: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2192: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ROUTING_ODS_LOAD.LOAD_OPERATION_NETWORKS');
2193: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2194: MSC_CL_ROUTING_ODS_LOAD.LOAD_OPERATION_NETWORKS;
2195:
2196: ELSIF pTASKNUM= PTASK_HARD_RESERVATION THEN
2197:

Line 2198: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');

2194: MSC_CL_ROUTING_ODS_LOAD.LOAD_OPERATION_NETWORKS;
2195:
2196: ELSIF pTASKNUM= PTASK_HARD_RESERVATION THEN
2197:
2198: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2199: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LOAD_HARD_RESERVATION');
2200: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2201: MSC_CL_DEMAND_ODS_LOAD.LOAD_HARD_RESERVATION;
2202:

Line 2199: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LOAD_HARD_RESERVATION');

2195:
2196: ELSIF pTASKNUM= PTASK_HARD_RESERVATION THEN
2197:
2198: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2199: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LOAD_HARD_RESERVATION');
2200: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2201: MSC_CL_DEMAND_ODS_LOAD.LOAD_HARD_RESERVATION;
2202:
2203: ELSIF pTASKNUM= PTASK_SOURCING THEN

Line 2200: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

2196: ELSIF pTASKNUM= PTASK_HARD_RESERVATION THEN
2197:
2198: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2199: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LOAD_HARD_RESERVATION');
2200: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2201: MSC_CL_DEMAND_ODS_LOAD.LOAD_HARD_RESERVATION;
2202:
2203: ELSIF pTASKNUM= PTASK_SOURCING THEN
2204:

Line 2205: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');

2201: MSC_CL_DEMAND_ODS_LOAD.LOAD_HARD_RESERVATION;
2202:
2203: ELSIF pTASKNUM= PTASK_SOURCING THEN
2204:
2205: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2206: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_SOURCING');
2207: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2208: MSC_CL_OTHER_ODS_LOAD.LOAD_SOURCING;
2209:

Line 2206: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_SOURCING');

2202:
2203: ELSIF pTASKNUM= PTASK_SOURCING THEN
2204:
2205: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2206: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_SOURCING');
2207: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2208: MSC_CL_OTHER_ODS_LOAD.LOAD_SOURCING;
2209:
2210: ELSIF pTASKNUM= PTASK_SAFETY_STOCK THEN

Line 2207: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

2203: ELSIF pTASKNUM= PTASK_SOURCING THEN
2204:
2205: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2206: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_SOURCING');
2207: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2208: MSC_CL_OTHER_ODS_LOAD.LOAD_SOURCING;
2209:
2210: ELSIF pTASKNUM= PTASK_SAFETY_STOCK THEN
2211:

Line 2212: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');

2208: MSC_CL_OTHER_ODS_LOAD.LOAD_SOURCING;
2209:
2210: ELSIF pTASKNUM= PTASK_SAFETY_STOCK THEN
2211:
2212: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2213: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_SAFETY_STOCK');
2214: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2215: MSC_CL_OTHER_ODS_LOAD.LOAD_SAFETY_STOCK;
2216:

Line 2213: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_SAFETY_STOCK');

2209:
2210: ELSIF pTASKNUM= PTASK_SAFETY_STOCK THEN
2211:
2212: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2213: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_SAFETY_STOCK');
2214: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2215: MSC_CL_OTHER_ODS_LOAD.LOAD_SAFETY_STOCK;
2216:
2217: ELSIF pTASKNUM= PTASK_MDS_DEMAND THEN

Line 2214: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

2210: ELSIF pTASKNUM= PTASK_SAFETY_STOCK THEN
2211:
2212: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2213: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_SAFETY_STOCK');
2214: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2215: MSC_CL_OTHER_ODS_LOAD.LOAD_SAFETY_STOCK;
2216:
2217: ELSIF pTASKNUM= PTASK_MDS_DEMAND THEN
2218:

Line 2247: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');

2243: (v_coll_prec.supplier_response_flag = MSC_UTIL.SYS_YES) or
2244: (v_coll_prec.user_supply_demand_flag = MSC_UTIL.SYS_YES) ) THEN
2245:
2246: IF MSC_CL_SUPPLY_ODS_LOAD.IS_SUPPLIES_LOAD_DONE THEN
2247: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2248: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LOAD_DEMAND');
2249: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2250: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'Calling MSC_CL_DEMAND_ODS_LOAD.LOAD_DEMAND From PTASK_MDS_DEMAND -- Either MDS Is targetted');
2251: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'or all the demands are incremental or None in this run. ');

Line 2248: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LOAD_DEMAND');

2244: (v_coll_prec.user_supply_demand_flag = MSC_UTIL.SYS_YES) ) THEN
2245:
2246: IF MSC_CL_SUPPLY_ODS_LOAD.IS_SUPPLIES_LOAD_DONE THEN
2247: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2248: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LOAD_DEMAND');
2249: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2250: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'Calling MSC_CL_DEMAND_ODS_LOAD.LOAD_DEMAND From PTASK_MDS_DEMAND -- Either MDS Is targetted');
2251: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'or all the demands are incremental or None in this run. ');
2252: MSC_CL_DEMAND_ODS_LOAD.LOAD_DEMAND;

Line 2249: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

2245:
2246: IF MSC_CL_SUPPLY_ODS_LOAD.IS_SUPPLIES_LOAD_DONE THEN
2247: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2248: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LOAD_DEMAND');
2249: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2250: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'Calling MSC_CL_DEMAND_ODS_LOAD.LOAD_DEMAND From PTASK_MDS_DEMAND -- Either MDS Is targetted');
2251: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'or all the demands are incremental or None in this run. ');
2252: MSC_CL_DEMAND_ODS_LOAD.LOAD_DEMAND;
2253: ELSE

Line 2259: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');

2255: RAISE SUPPLIES_LOAD_FAIL;
2256: END IF;
2257:
2258: ELSE
2259: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2260: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LOAD_DEMAND');
2261: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2262: MSC_CL_DEMAND_ODS_LOAD.LOAD_DEMAND;
2263: END IF;

Line 2260: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LOAD_DEMAND');

2256: END IF;
2257:
2258: ELSE
2259: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2260: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LOAD_DEMAND');
2261: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2262: MSC_CL_DEMAND_ODS_LOAD.LOAD_DEMAND;
2263: END IF;
2264:

Line 2261: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

2257:
2258: ELSE
2259: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2260: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LOAD_DEMAND');
2261: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2262: MSC_CL_DEMAND_ODS_LOAD.LOAD_DEMAND;
2263: END IF;
2264:
2265: END IF;

Line 2270: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');

2266:
2267: ELSIF pTASKNUM = PTASK_WIP_RES_REQ THEN
2268:
2269: IF MSC_CL_SUPPLY_ODS_LOAD.IS_SUPPLIES_LOAD_DONE THEN
2270: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2271: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_WIP_ODS_LOAD.LOAD_RES_REQ');
2272: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2273: MSC_CL_WIP_ODS_LOAD.LOAD_RES_REQ;
2274: ELSE

Line 2271: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_WIP_ODS_LOAD.LOAD_RES_REQ');

2267: ELSIF pTASKNUM = PTASK_WIP_RES_REQ THEN
2268:
2269: IF MSC_CL_SUPPLY_ODS_LOAD.IS_SUPPLIES_LOAD_DONE THEN
2270: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2271: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_WIP_ODS_LOAD.LOAD_RES_REQ');
2272: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2273: MSC_CL_WIP_ODS_LOAD.LOAD_RES_REQ;
2274: ELSE
2275: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, 'Loading of Supplies failed. PTASK_WIP_RES_REQ');

Line 2272: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

2268:
2269: IF MSC_CL_SUPPLY_ODS_LOAD.IS_SUPPLIES_LOAD_DONE THEN
2270: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2271: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_WIP_ODS_LOAD.LOAD_RES_REQ');
2272: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2273: MSC_CL_WIP_ODS_LOAD.LOAD_RES_REQ;
2274: ELSE
2275: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, 'Loading of Supplies failed. PTASK_WIP_RES_REQ');
2276: RAISE SUPPLIES_LOAD_FAIL;

Line 2293: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');

2289: (v_coll_prec.user_supply_demand_flag = MSC_UTIL.SYS_NO or
2290: (v_coll_prec.user_supply_demand_flag = MSC_UTIL.SYS_YES and v_coll_prec.udmd_sn_flag <>MSC_UTIL.SYS_TGT))
2291: ) ))) THEN
2292: IF MSC_CL_SUPPLY_ODS_LOAD.IS_SUPPLIES_LOAD_DONE THEN
2293: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2294: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_WIP_ODS_LOAD.LOAD_WIP_DEMAND');
2295: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2296: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'Calling LOAD_WIP_DEMAND From PTASK_WIP_DEMAND -- Either WIP is Targetted ');
2297: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'or all the demands are incremental or None in this run. ');

Line 2294: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_WIP_ODS_LOAD.LOAD_WIP_DEMAND');

2290: (v_coll_prec.user_supply_demand_flag = MSC_UTIL.SYS_YES and v_coll_prec.udmd_sn_flag <>MSC_UTIL.SYS_TGT))
2291: ) ))) THEN
2292: IF MSC_CL_SUPPLY_ODS_LOAD.IS_SUPPLIES_LOAD_DONE THEN
2293: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2294: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_WIP_ODS_LOAD.LOAD_WIP_DEMAND');
2295: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2296: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'Calling LOAD_WIP_DEMAND From PTASK_WIP_DEMAND -- Either WIP is Targetted ');
2297: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'or all the demands are incremental or None in this run. ');
2298: MSC_CL_WIP_ODS_LOAD.LOAD_WIP_DEMAND;

Line 2295: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

2291: ) ))) THEN
2292: IF MSC_CL_SUPPLY_ODS_LOAD.IS_SUPPLIES_LOAD_DONE THEN
2293: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2294: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_WIP_ODS_LOAD.LOAD_WIP_DEMAND');
2295: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2296: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'Calling LOAD_WIP_DEMAND From PTASK_WIP_DEMAND -- Either WIP is Targetted ');
2297: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'or all the demands are incremental or None in this run. ');
2298: MSC_CL_WIP_ODS_LOAD.LOAD_WIP_DEMAND;
2299: ELSE

Line 2319: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');

2315: (v_coll_prec.user_supply_demand_flag = MSC_UTIL.SYS_NO or
2316: (v_coll_prec.user_supply_demand_flag = MSC_UTIL.SYS_YES and v_coll_prec.udmd_sn_flag <>MSC_UTIL.SYS_TGT))
2317: )))) THEN
2318:
2319: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2320: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'LOAD_ITEM_FORECAST');
2321: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2322: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'Calling LOAD_ITEM_FORECAST From PTASK_FORECAST_DEMAND-- Either forecast id Targetted ');
2323: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'or all the demands are incremental or None in this run. ');

Line 2320: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'LOAD_ITEM_FORECAST');

2316: (v_coll_prec.user_supply_demand_flag = MSC_UTIL.SYS_YES and v_coll_prec.udmd_sn_flag <>MSC_UTIL.SYS_TGT))
2317: )))) THEN
2318:
2319: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2320: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'LOAD_ITEM_FORECAST');
2321: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2322: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'Calling LOAD_ITEM_FORECAST From PTASK_FORECAST_DEMAND-- Either forecast id Targetted ');
2323: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'or all the demands are incremental or None in this run. ');
2324: MSC_CL_DEMAND_ODS_LOAD.LOAD_ITEM_FORECASTS;

Line 2321: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

2317: )))) THEN
2318:
2319: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2320: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'LOAD_ITEM_FORECAST');
2321: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2322: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'Calling LOAD_ITEM_FORECAST From PTASK_FORECAST_DEMAND-- Either forecast id Targetted ');
2323: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'or all the demands are incremental or None in this run. ');
2324: MSC_CL_DEMAND_ODS_LOAD.LOAD_ITEM_FORECASTS;
2325:

Line 2342: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');

2338: (v_coll_prec.user_supply_demand_flag = MSC_UTIL.SYS_YES and v_coll_prec.udmd_sn_flag = MSC_UTIL.SYS_TGT) OR
2339: (v_coll_prec.mds_flag = MSC_UTIL.SYS_YES and v_coll_prec.mds_sn_flag = MSC_UTIL.SYS_TGT) ) THEN
2340:
2341: IF (v_coll_prec.forecast_flag = MSC_UTIL.SYS_YES and v_coll_prec.fcst_sn_flag = MSC_UTIL.SYS_INCR) THEN
2342: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2343: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'LOAD_ITEM_FORECAST');
2344: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2345: v_is_incremental_refresh := TRUE;
2346: v_exchange_mode := MSC_UTIL.SYS_NO;

Line 2343: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'LOAD_ITEM_FORECAST');

2339: (v_coll_prec.mds_flag = MSC_UTIL.SYS_YES and v_coll_prec.mds_sn_flag = MSC_UTIL.SYS_TGT) ) THEN
2340:
2341: IF (v_coll_prec.forecast_flag = MSC_UTIL.SYS_YES and v_coll_prec.fcst_sn_flag = MSC_UTIL.SYS_INCR) THEN
2342: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2343: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'LOAD_ITEM_FORECAST');
2344: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2345: v_is_incremental_refresh := TRUE;
2346: v_exchange_mode := MSC_UTIL.SYS_NO;
2347: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'Calling Incremental MSC_CL_DEMAND_ODS_LOAD.LOAD_ITEM_FORECASTS From PTASK_ODS_DEMAND');

Line 2344: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

2340:
2341: IF (v_coll_prec.forecast_flag = MSC_UTIL.SYS_YES and v_coll_prec.fcst_sn_flag = MSC_UTIL.SYS_INCR) THEN
2342: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2343: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'LOAD_ITEM_FORECAST');
2344: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2345: v_is_incremental_refresh := TRUE;
2346: v_exchange_mode := MSC_UTIL.SYS_NO;
2347: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'Calling Incremental MSC_CL_DEMAND_ODS_LOAD.LOAD_ITEM_FORECASTS From PTASK_ODS_DEMAND');
2348: MSC_CL_DEMAND_ODS_LOAD.LOAD_ITEM_FORECASTS;

Line 2353: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');

2349: END IF;
2350:
2351: IF (v_coll_prec.wip_flag = MSC_UTIL.SYS_YES and v_coll_prec.wip_sn_flag = MSC_UTIL.SYS_INCR) THEN
2352: IF MSC_CL_SUPPLY_ODS_LOAD.IS_SUPPLIES_LOAD_DONE THEN
2353: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2354: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_WIP_ODS_LOAD.LOAD_WIP_DEMAND');
2355: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2356: v_is_incremental_refresh := TRUE;
2357: v_exchange_mode := MSC_UTIL.SYS_NO;

Line 2354: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_WIP_ODS_LOAD.LOAD_WIP_DEMAND');

2350:
2351: IF (v_coll_prec.wip_flag = MSC_UTIL.SYS_YES and v_coll_prec.wip_sn_flag = MSC_UTIL.SYS_INCR) THEN
2352: IF MSC_CL_SUPPLY_ODS_LOAD.IS_SUPPLIES_LOAD_DONE THEN
2353: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2354: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_WIP_ODS_LOAD.LOAD_WIP_DEMAND');
2355: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2356: v_is_incremental_refresh := TRUE;
2357: v_exchange_mode := MSC_UTIL.SYS_NO;
2358: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'Calling Incremental LOAD_WIP_DEMAND From PTASK_ODS_DEMAND');

Line 2355: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

2351: IF (v_coll_prec.wip_flag = MSC_UTIL.SYS_YES and v_coll_prec.wip_sn_flag = MSC_UTIL.SYS_INCR) THEN
2352: IF MSC_CL_SUPPLY_ODS_LOAD.IS_SUPPLIES_LOAD_DONE THEN
2353: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2354: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_WIP_ODS_LOAD.LOAD_WIP_DEMAND');
2355: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2356: v_is_incremental_refresh := TRUE;
2357: v_exchange_mode := MSC_UTIL.SYS_NO;
2358: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'Calling Incremental LOAD_WIP_DEMAND From PTASK_ODS_DEMAND');
2359: MSC_CL_WIP_ODS_LOAD.LOAD_WIP_DEMAND;

Line 2376: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');

2372: (v_coll_prec.supplier_response_flag = MSC_UTIL.SYS_YES) or
2373: (v_coll_prec.user_supply_demand_flag = MSC_UTIL.SYS_YES) ) THEN
2374:
2375: IF MSC_CL_SUPPLY_ODS_LOAD.IS_SUPPLIES_LOAD_DONE THEN
2376: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2377: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LOAD_DEMAND');
2378: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2379: v_is_incremental_refresh := TRUE;
2380: v_exchange_mode := MSC_UTIL.SYS_NO;

Line 2377: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LOAD_DEMAND');

2373: (v_coll_prec.user_supply_demand_flag = MSC_UTIL.SYS_YES) ) THEN
2374:
2375: IF MSC_CL_SUPPLY_ODS_LOAD.IS_SUPPLIES_LOAD_DONE THEN
2376: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2377: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LOAD_DEMAND');
2378: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2379: v_is_incremental_refresh := TRUE;
2380: v_exchange_mode := MSC_UTIL.SYS_NO;
2381: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'Calling Incremental MSC_CL_DEMAND_ODS_LOAD.LOAD_DEMAND From PTASK_ODS_DEMAND');

Line 2378: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

2374:
2375: IF MSC_CL_SUPPLY_ODS_LOAD.IS_SUPPLIES_LOAD_DONE THEN
2376: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2377: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LOAD_DEMAND');
2378: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2379: v_is_incremental_refresh := TRUE;
2380: v_exchange_mode := MSC_UTIL.SYS_NO;
2381: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'Calling Incremental MSC_CL_DEMAND_ODS_LOAD.LOAD_DEMAND From PTASK_ODS_DEMAND');
2382: MSC_CL_DEMAND_ODS_LOAD.LOAD_DEMAND;

Line 2389: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');

2385: RAISE SUPPLIES_LOAD_FAIL;
2386: END IF;
2387:
2388: ELSE --- all the supplies flag are no
2389: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2390: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LOAD_DEMAND');
2391: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2392: v_is_incremental_refresh := TRUE;
2393: v_exchange_mode := MSC_UTIL.SYS_NO;

Line 2390: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LOAD_DEMAND');

2386: END IF;
2387:
2388: ELSE --- all the supplies flag are no
2389: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2390: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LOAD_DEMAND');
2391: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2392: v_is_incremental_refresh := TRUE;
2393: v_exchange_mode := MSC_UTIL.SYS_NO;
2394: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'Calling Incremental MSC_CL_DEMAND_ODS_LOAD.LOAD_DEMAND From PTASK_ODS_DEMAND -- No Supplies are Collected in this run');

Line 2391: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

2387:
2388: ELSE --- all the supplies flag are no
2389: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2390: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LOAD_DEMAND');
2391: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2392: v_is_incremental_refresh := TRUE;
2393: v_exchange_mode := MSC_UTIL.SYS_NO;
2394: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'Calling Incremental MSC_CL_DEMAND_ODS_LOAD.LOAD_DEMAND From PTASK_ODS_DEMAND -- No Supplies are Collected in this run');
2395: MSC_CL_DEMAND_ODS_LOAD.LOAD_DEMAND;

Line 2405: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');

2401:
2402: /* AFTER HANDLING OTHER DEMANDS INCREMENTAL PERFORM THE MSC_CL_DEMAND_ODS_LOAD.LOAD_ODS_DEMAND */
2403: /* -------------------------------------------------------------------- */
2404:
2405: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2406: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LOAD_ODS_DEMAND');
2407: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2408: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'Calling MSC_CL_DEMAND_ODS_LOAD.LOAD_ODS_DEMAND From PTASK_ODS_DEMAND -- One of the Demands is Targetted in this run');
2409: MSC_CL_DEMAND_ODS_LOAD.LOAD_ODS_DEMAND;

Line 2406: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LOAD_ODS_DEMAND');

2402: /* AFTER HANDLING OTHER DEMANDS INCREMENTAL PERFORM THE MSC_CL_DEMAND_ODS_LOAD.LOAD_ODS_DEMAND */
2403: /* -------------------------------------------------------------------- */
2404:
2405: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2406: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LOAD_ODS_DEMAND');
2407: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2408: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'Calling MSC_CL_DEMAND_ODS_LOAD.LOAD_ODS_DEMAND From PTASK_ODS_DEMAND -- One of the Demands is Targetted in this run');
2409: MSC_CL_DEMAND_ODS_LOAD.LOAD_ODS_DEMAND;
2410:

Line 2407: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

2403: /* -------------------------------------------------------------------- */
2404:
2405: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2406: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LOAD_ODS_DEMAND');
2407: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2408: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'Calling MSC_CL_DEMAND_ODS_LOAD.LOAD_ODS_DEMAND From PTASK_ODS_DEMAND -- One of the Demands is Targetted in this run');
2409: MSC_CL_DEMAND_ODS_LOAD.LOAD_ODS_DEMAND;
2410:
2411: END IF; -- Is any Demand Targetted in Continous

Line 2415: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');

2411: END IF; -- Is any Demand Targetted in Continous
2412:
2413: elsif (v_is_partial_refresh) THEN -- Targeted collections
2414:
2415: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2416: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LOAD_ODS_DEMAND');
2417: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2418: MSC_CL_DEMAND_ODS_LOAD.LOAD_ODS_DEMAND;
2419: -- Load Demand information from ODS table into

Line 2416: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LOAD_ODS_DEMAND');

2412:
2413: elsif (v_is_partial_refresh) THEN -- Targeted collections
2414:
2415: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2416: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LOAD_ODS_DEMAND');
2417: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2418: MSC_CL_DEMAND_ODS_LOAD.LOAD_ODS_DEMAND;
2419: -- Load Demand information from ODS table into
2420: -- the temp table.

Line 2417: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

2413: elsif (v_is_partial_refresh) THEN -- Targeted collections
2414:
2415: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2416: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LOAD_ODS_DEMAND');
2417: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2418: MSC_CL_DEMAND_ODS_LOAD.LOAD_ODS_DEMAND;
2419: -- Load Demand information from ODS table into
2420: -- the temp table.
2421: end if;

Line 2453: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');

2449: (v_coll_prec.supplier_response_flag = MSC_UTIL.SYS_YES and v_coll_prec.suprep_sn_flag = MSC_UTIL.SYS_INCR) or
2450: (v_coll_prec.oh_flag = MSC_UTIL.SYS_YES and v_coll_prec.oh_sn_flag = MSC_UTIL.SYS_INCR) or
2451: (v_coll_prec.user_supply_demand_flag = MSC_UTIL.SYS_YES and v_coll_prec.usup_sn_flag = MSC_UTIL.SYS_INCR) then
2452:
2453: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2454: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SUPPLY_ODS_LOAD.LOAD_SUPPLY');
2455: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2456: v_exchange_mode := MSC_UTIL.SYS_NO;
2457: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'PTASK_SUPPLY: before MSC_CL_SUPPLY_ODS_LOAD.LOAD_SUPPLY ');

Line 2454: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SUPPLY_ODS_LOAD.LOAD_SUPPLY');

2450: (v_coll_prec.oh_flag = MSC_UTIL.SYS_YES and v_coll_prec.oh_sn_flag = MSC_UTIL.SYS_INCR) or
2451: (v_coll_prec.user_supply_demand_flag = MSC_UTIL.SYS_YES and v_coll_prec.usup_sn_flag = MSC_UTIL.SYS_INCR) then
2452:
2453: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2454: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SUPPLY_ODS_LOAD.LOAD_SUPPLY');
2455: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2456: v_exchange_mode := MSC_UTIL.SYS_NO;
2457: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'PTASK_SUPPLY: before MSC_CL_SUPPLY_ODS_LOAD.LOAD_SUPPLY ');
2458: MSC_CL_SUPPLY_ODS_LOAD.LOAD_SUPPLY;

Line 2455: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

2451: (v_coll_prec.user_supply_demand_flag = MSC_UTIL.SYS_YES and v_coll_prec.usup_sn_flag = MSC_UTIL.SYS_INCR) then
2452:
2453: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2454: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SUPPLY_ODS_LOAD.LOAD_SUPPLY');
2455: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2456: v_exchange_mode := MSC_UTIL.SYS_NO;
2457: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'PTASK_SUPPLY: before MSC_CL_SUPPLY_ODS_LOAD.LOAD_SUPPLY ');
2458: MSC_CL_SUPPLY_ODS_LOAD.LOAD_SUPPLY;
2459: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'PTASK_SUPPLY: after MSC_CL_SUPPLY_ODS_LOAD.LOAD_SUPPLY ');

Line 2475: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');

2471: (v_coll_prec.supplier_response_flag = MSC_UTIL.SYS_YES and v_coll_prec.suprep_sn_flag = MSC_UTIL.SYS_TGT) or
2472: (v_coll_prec.user_supply_demand_flag = MSC_UTIL.SYS_YES and v_coll_prec.usup_sn_flag = MSC_UTIL.SYS_TGT) then
2473: -- Load Supply information from staging tables
2474: -- into the temp table.
2475: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2476: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SUPPLY_ODS_LOAD.LOAD_STAGING_SUPPLY');
2477: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2478: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'PTASK_SUPPLY: before MSC_CL_SUPPLY_ODS_LOAD.LOAD_STAGING_SUPPLY ');
2479: MSC_CL_SUPPLY_ODS_LOAD.LOAD_STAGING_SUPPLY;

Line 2476: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SUPPLY_ODS_LOAD.LOAD_STAGING_SUPPLY');

2472: (v_coll_prec.user_supply_demand_flag = MSC_UTIL.SYS_YES and v_coll_prec.usup_sn_flag = MSC_UTIL.SYS_TGT) then
2473: -- Load Supply information from staging tables
2474: -- into the temp table.
2475: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2476: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SUPPLY_ODS_LOAD.LOAD_STAGING_SUPPLY');
2477: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2478: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'PTASK_SUPPLY: before MSC_CL_SUPPLY_ODS_LOAD.LOAD_STAGING_SUPPLY ');
2479: MSC_CL_SUPPLY_ODS_LOAD.LOAD_STAGING_SUPPLY;
2480: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'PTASK_SUPPLY: after MSC_CL_SUPPLY_ODS_LOAD.LOAD_STAGING_SUPPLY ');

Line 2477: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

2473: -- Load Supply information from staging tables
2474: -- into the temp table.
2475: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2476: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SUPPLY_ODS_LOAD.LOAD_STAGING_SUPPLY');
2477: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2478: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'PTASK_SUPPLY: before MSC_CL_SUPPLY_ODS_LOAD.LOAD_STAGING_SUPPLY ');
2479: MSC_CL_SUPPLY_ODS_LOAD.LOAD_STAGING_SUPPLY;
2480: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'PTASK_SUPPLY: after MSC_CL_SUPPLY_ODS_LOAD.LOAD_STAGING_SUPPLY ');
2481: -- Load Supply information from ODS table

Line 2483: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');

2479: MSC_CL_SUPPLY_ODS_LOAD.LOAD_STAGING_SUPPLY;
2480: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'PTASK_SUPPLY: after MSC_CL_SUPPLY_ODS_LOAD.LOAD_STAGING_SUPPLY ');
2481: -- Load Supply information from ODS table
2482: -- into the temp table.
2483: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2484: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SUPPLY_ODS_LOAD.LOAD_ODS_SUPPLY');
2485: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2486: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'PTASK_SUPPLY: befor MSC_CL_SUPPLY_ODS_LOAD.LOAD_ODS_SUPPLY ');
2487: MSC_CL_SUPPLY_ODS_LOAD.LOAD_ODS_SUPPLY;

Line 2484: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SUPPLY_ODS_LOAD.LOAD_ODS_SUPPLY');

2480: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'PTASK_SUPPLY: after MSC_CL_SUPPLY_ODS_LOAD.LOAD_STAGING_SUPPLY ');
2481: -- Load Supply information from ODS table
2482: -- into the temp table.
2483: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2484: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SUPPLY_ODS_LOAD.LOAD_ODS_SUPPLY');
2485: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2486: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'PTASK_SUPPLY: befor MSC_CL_SUPPLY_ODS_LOAD.LOAD_ODS_SUPPLY ');
2487: MSC_CL_SUPPLY_ODS_LOAD.LOAD_ODS_SUPPLY;
2488: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'PTASK_SUPPLY: after MSC_CL_SUPPLY_ODS_LOAD.LOAD_ODS_SUPPLY ');

Line 2485: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

2481: -- Load Supply information from ODS table
2482: -- into the temp table.
2483: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2484: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SUPPLY_ODS_LOAD.LOAD_ODS_SUPPLY');
2485: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2486: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'PTASK_SUPPLY: befor MSC_CL_SUPPLY_ODS_LOAD.LOAD_ODS_SUPPLY ');
2487: MSC_CL_SUPPLY_ODS_LOAD.LOAD_ODS_SUPPLY;
2488: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'PTASK_SUPPLY: after MSC_CL_SUPPLY_ODS_LOAD.LOAD_ODS_SUPPLY ');
2489:

Line 2504: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');

2500: end if; --- any one of the Supplies will be done Targeted
2501:
2502: ELSIF (v_is_incremental_refresh) then
2503: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, 'ds debug: v_is_incremental_refresh MSC_CL_SUPPLY_ODS_LOAD.LOAD_SUPPLY');
2504: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2505: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SUPPLY_ODS_LOAD.LOAD_SUPPLY');
2506: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2507: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'PTASK_SUPPLY:v_is_incremental_refresh before MSC_CL_SUPPLY_ODS_LOAD.LOAD_SUPPLY ');
2508: MSC_CL_SUPPLY_ODS_LOAD.LOAD_SUPPLY;

Line 2505: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SUPPLY_ODS_LOAD.LOAD_SUPPLY');

2501:
2502: ELSIF (v_is_incremental_refresh) then
2503: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, 'ds debug: v_is_incremental_refresh MSC_CL_SUPPLY_ODS_LOAD.LOAD_SUPPLY');
2504: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2505: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SUPPLY_ODS_LOAD.LOAD_SUPPLY');
2506: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2507: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'PTASK_SUPPLY:v_is_incremental_refresh before MSC_CL_SUPPLY_ODS_LOAD.LOAD_SUPPLY ');
2508: MSC_CL_SUPPLY_ODS_LOAD.LOAD_SUPPLY;
2509: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'PTASK_SUPPLY:v_is_incremental_refresh after MSC_CL_SUPPLY_ODS_LOAD.LOAD_SUPPLY ');

Line 2506: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

2502: ELSIF (v_is_incremental_refresh) then
2503: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, 'ds debug: v_is_incremental_refresh MSC_CL_SUPPLY_ODS_LOAD.LOAD_SUPPLY');
2504: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2505: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SUPPLY_ODS_LOAD.LOAD_SUPPLY');
2506: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2507: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'PTASK_SUPPLY:v_is_incremental_refresh before MSC_CL_SUPPLY_ODS_LOAD.LOAD_SUPPLY ');
2508: MSC_CL_SUPPLY_ODS_LOAD.LOAD_SUPPLY;
2509: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'PTASK_SUPPLY:v_is_incremental_refresh after MSC_CL_SUPPLY_ODS_LOAD.LOAD_SUPPLY ');
2510: ELSE ---- Targeted Collections

Line 2514: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');

2510: ELSE ---- Targeted Collections
2511: -- Load Supply information from staging tables
2512: -- into the temp table.
2513: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'ds debug: Targetted MSC_CL_SUPPLY_ODS_LOAD.LOAD_ODS_SUPPLY');
2514: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2515: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SUPPLY_ODS_LOAD.LOAD_STAGING_SUPPLY');
2516: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2517: MSC_CL_SUPPLY_ODS_LOAD.LOAD_STAGING_SUPPLY;
2518: -- Load Supply information from ODS table

Line 2515: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SUPPLY_ODS_LOAD.LOAD_STAGING_SUPPLY');

2511: -- Load Supply information from staging tables
2512: -- into the temp table.
2513: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'ds debug: Targetted MSC_CL_SUPPLY_ODS_LOAD.LOAD_ODS_SUPPLY');
2514: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2515: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SUPPLY_ODS_LOAD.LOAD_STAGING_SUPPLY');
2516: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2517: MSC_CL_SUPPLY_ODS_LOAD.LOAD_STAGING_SUPPLY;
2518: -- Load Supply information from ODS table
2519: -- into the temp table.

Line 2516: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

2512: -- into the temp table.
2513: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'ds debug: Targetted MSC_CL_SUPPLY_ODS_LOAD.LOAD_ODS_SUPPLY');
2514: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2515: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SUPPLY_ODS_LOAD.LOAD_STAGING_SUPPLY');
2516: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2517: MSC_CL_SUPPLY_ODS_LOAD.LOAD_STAGING_SUPPLY;
2518: -- Load Supply information from ODS table
2519: -- into the temp table.
2520: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');

Line 2520: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');

2516: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2517: MSC_CL_SUPPLY_ODS_LOAD.LOAD_STAGING_SUPPLY;
2518: -- Load Supply information from ODS table
2519: -- into the temp table.
2520: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2521: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SUPPLY_ODS_LOAD.LOAD_ODS_SUPPLY');
2522: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2523: MSC_CL_SUPPLY_ODS_LOAD.LOAD_ODS_SUPPLY;
2524:

Line 2521: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SUPPLY_ODS_LOAD.LOAD_ODS_SUPPLY');

2517: MSC_CL_SUPPLY_ODS_LOAD.LOAD_STAGING_SUPPLY;
2518: -- Load Supply information from ODS table
2519: -- into the temp table.
2520: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2521: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SUPPLY_ODS_LOAD.LOAD_ODS_SUPPLY');
2522: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2523: MSC_CL_SUPPLY_ODS_LOAD.LOAD_ODS_SUPPLY;
2524:
2525: /*added by raraghav*/

Line 2522: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

2518: -- Load Supply information from ODS table
2519: -- into the temp table.
2520: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2521: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SUPPLY_ODS_LOAD.LOAD_ODS_SUPPLY');
2522: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2523: MSC_CL_SUPPLY_ODS_LOAD.LOAD_ODS_SUPPLY;
2524:
2525: /*added by raraghav*/
2526:

Line 2592: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');

2588:
2589: -- If any of the supply flags are enabled then wait for supplies to get finished
2590: IF MSC_CL_SUPPLY_ODS_LOAD.IS_SUPPLIES_LOAD_DONE THEN
2591: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, ' Calling MSC_CL_DEMAND_ODS_LOAD.LOAD_SALES_ORDER_2 ...');
2592: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2593: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LOAD_SALES_ORDER');
2594: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2595: MSC_CL_DEMAND_ODS_LOAD.LOAD_SALES_ORDER;
2596: ELSE

Line 2593: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LOAD_SALES_ORDER');

2589: -- If any of the supply flags are enabled then wait for supplies to get finished
2590: IF MSC_CL_SUPPLY_ODS_LOAD.IS_SUPPLIES_LOAD_DONE THEN
2591: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, ' Calling MSC_CL_DEMAND_ODS_LOAD.LOAD_SALES_ORDER_2 ...');
2592: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2593: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LOAD_SALES_ORDER');
2594: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2595: MSC_CL_DEMAND_ODS_LOAD.LOAD_SALES_ORDER;
2596: ELSE
2597: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, 'Loading of Supplies failed.MSC_CL_DEMAND_ODS_LOAD.LOAD_SALES_ORDER');

Line 2594: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

2590: IF MSC_CL_SUPPLY_ODS_LOAD.IS_SUPPLIES_LOAD_DONE THEN
2591: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, ' Calling MSC_CL_DEMAND_ODS_LOAD.LOAD_SALES_ORDER_2 ...');
2592: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2593: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LOAD_SALES_ORDER');
2594: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2595: MSC_CL_DEMAND_ODS_LOAD.LOAD_SALES_ORDER;
2596: ELSE
2597: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, 'Loading of Supplies failed.MSC_CL_DEMAND_ODS_LOAD.LOAD_SALES_ORDER');
2598: RAISE SUPPLIES_LOAD_FAIL;

Line 2603: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');

2599: END IF;
2600:
2601: ELSE -- no need to wait for supplies
2602: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, ' Calling MSC_CL_DEMAND_ODS_LOAD.LOAD_SALES_ORDER_2 ...');
2603: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2604: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LOAD_SALES_ORDER');
2605: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2606: MSC_CL_DEMAND_ODS_LOAD.LOAD_SALES_ORDER;
2607: END IF;

Line 2604: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LOAD_SALES_ORDER');

2600:
2601: ELSE -- no need to wait for supplies
2602: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, ' Calling MSC_CL_DEMAND_ODS_LOAD.LOAD_SALES_ORDER_2 ...');
2603: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2604: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LOAD_SALES_ORDER');
2605: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2606: MSC_CL_DEMAND_ODS_LOAD.LOAD_SALES_ORDER;
2607: END IF;
2608:

Line 2605: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

2601: ELSE -- no need to wait for supplies
2602: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, ' Calling MSC_CL_DEMAND_ODS_LOAD.LOAD_SALES_ORDER_2 ...');
2603: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2604: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LOAD_SALES_ORDER');
2605: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2606: MSC_CL_DEMAND_ODS_LOAD.LOAD_SALES_ORDER;
2607: END IF;
2608:
2609: IF ( v_is_so_incremental_refresh ) THEN

Line 2613: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');

2609: IF ( v_is_so_incremental_refresh ) THEN
2610: IF ( v_apps_ver >= MSC_UTIL.G_APPS115 ) THEN
2611:
2612: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, ' Calling Linking of Sales Order for 11i source ...');
2613: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2614: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LINK_SUPP_SO_DEMAND_11I2');
2615: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2616: MSC_CL_DEMAND_ODS_LOAD.LINK_SUPP_SO_DEMAND_11I2;
2617: -- Calling the Linking of external Sales orders for the fix 2353397 --

Line 2614: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LINK_SUPP_SO_DEMAND_11I2');

2610: IF ( v_apps_ver >= MSC_UTIL.G_APPS115 ) THEN
2611:
2612: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, ' Calling Linking of Sales Order for 11i source ...');
2613: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2614: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LINK_SUPP_SO_DEMAND_11I2');
2615: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2616: MSC_CL_DEMAND_ODS_LOAD.LINK_SUPP_SO_DEMAND_11I2;
2617: -- Calling the Linking of external Sales orders for the fix 2353397 --
2618: -- MSC_CL_DEMAND_ODS_LOAD.LINK_SUPP_SO_DEMAND_EXT;

Line 2615: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

2611:
2612: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, ' Calling Linking of Sales Order for 11i source ...');
2613: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2614: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LINK_SUPP_SO_DEMAND_11I2');
2615: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2616: MSC_CL_DEMAND_ODS_LOAD.LINK_SUPP_SO_DEMAND_11I2;
2617: -- Calling the Linking of external Sales orders for the fix 2353397 --
2618: -- MSC_CL_DEMAND_ODS_LOAD.LINK_SUPP_SO_DEMAND_EXT;
2619:

Line 2623: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');

2619:
2620: ELSIF ( v_apps_ver = MSC_UTIL.G_APPS110) THEN
2621:
2622: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, ' Calling Linking of Sales Order for 110 source ...');
2623: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2624: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LINK_SUPP_SO_DEMAND_110');
2625: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2626: MSC_CL_DEMAND_ODS_LOAD.LINK_SUPP_SO_DEMAND_110;
2627: END IF;

Line 2624: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LINK_SUPP_SO_DEMAND_110');

2620: ELSIF ( v_apps_ver = MSC_UTIL.G_APPS110) THEN
2621:
2622: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, ' Calling Linking of Sales Order for 110 source ...');
2623: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2624: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LINK_SUPP_SO_DEMAND_110');
2625: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2626: MSC_CL_DEMAND_ODS_LOAD.LINK_SUPP_SO_DEMAND_110;
2627: END IF;
2628: END IF;

Line 2625: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

2621:
2622: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, ' Calling Linking of Sales Order for 110 source ...');
2623: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2624: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LINK_SUPP_SO_DEMAND_110');
2625: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2626: MSC_CL_DEMAND_ODS_LOAD.LINK_SUPP_SO_DEMAND_110;
2627: END IF;
2628: END IF;
2629:

Line 2632: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');

2628: END IF;
2629:
2630: ELSIF pTASKNUM= PTASK_NET_RESOURCE_AVAIL THEN
2631:
2632: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2633: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_RESOURCE_AVAILABILITY.LOAD_NET_RESOURCE_AVAIL');
2634: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2635: MSC_RESOURCE_AVAILABILITY.LOAD_NET_RESOURCE_AVAIL;
2636:

Line 2633: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_RESOURCE_AVAILABILITY.LOAD_NET_RESOURCE_AVAIL');

2629:
2630: ELSIF pTASKNUM= PTASK_NET_RESOURCE_AVAIL THEN
2631:
2632: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2633: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_RESOURCE_AVAILABILITY.LOAD_NET_RESOURCE_AVAIL');
2634: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2635: MSC_RESOURCE_AVAILABILITY.LOAD_NET_RESOURCE_AVAIL;
2636:
2637: ELSIF pTASKNUM= PTASK_UOM THEN

Line 2634: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

2630: ELSIF pTASKNUM= PTASK_NET_RESOURCE_AVAIL THEN
2631:
2632: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2633: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_RESOURCE_AVAILABILITY.LOAD_NET_RESOURCE_AVAIL');
2634: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2635: MSC_RESOURCE_AVAILABILITY.LOAD_NET_RESOURCE_AVAIL;
2636:
2637: ELSIF pTASKNUM= PTASK_UOM THEN
2638:

Line 2639: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');

2635: MSC_RESOURCE_AVAILABILITY.LOAD_NET_RESOURCE_AVAIL;
2636:
2637: ELSIF pTASKNUM= PTASK_UOM THEN
2638:
2639: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2640: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SETUP_ODS_LOAD.LOAD_UOM');
2641: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2642: MSC_CL_SETUP_ODS_LOAD.LOAD_UOM;
2643:

Line 2640: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SETUP_ODS_LOAD.LOAD_UOM');

2636:
2637: ELSIF pTASKNUM= PTASK_UOM THEN
2638:
2639: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2640: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SETUP_ODS_LOAD.LOAD_UOM');
2641: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2642: MSC_CL_SETUP_ODS_LOAD.LOAD_UOM;
2643:
2644: ELSIF pTASKNUM= PTASK_ATP_RULES THEN

Line 2641: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

2637: ELSIF pTASKNUM= PTASK_UOM THEN
2638:
2639: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2640: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SETUP_ODS_LOAD.LOAD_UOM');
2641: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2642: MSC_CL_SETUP_ODS_LOAD.LOAD_UOM;
2643:
2644: ELSIF pTASKNUM= PTASK_ATP_RULES THEN
2645:

Line 2646: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');

2642: MSC_CL_SETUP_ODS_LOAD.LOAD_UOM;
2643:
2644: ELSIF pTASKNUM= PTASK_ATP_RULES THEN
2645:
2646: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2647: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_ATP_RULES');
2648: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2649: MSC_CL_OTHER_ODS_LOAD.LOAD_ATP_RULES;
2650:

Line 2647: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_ATP_RULES');

2643:
2644: ELSIF pTASKNUM= PTASK_ATP_RULES THEN
2645:
2646: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2647: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_ATP_RULES');
2648: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2649: MSC_CL_OTHER_ODS_LOAD.LOAD_ATP_RULES;
2650:
2651: ELSIF pTASKNUM= PTASK_BOR THEN

Line 2648: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

2644: ELSIF pTASKNUM= PTASK_ATP_RULES THEN
2645:
2646: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2647: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_ATP_RULES');
2648: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2649: MSC_CL_OTHER_ODS_LOAD.LOAD_ATP_RULES;
2650:
2651: ELSIF pTASKNUM= PTASK_BOR THEN
2652:

Line 2653: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');

2649: MSC_CL_OTHER_ODS_LOAD.LOAD_ATP_RULES;
2650:
2651: ELSIF pTASKNUM= PTASK_BOR THEN
2652:
2653: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2654: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_BOM_ODS_LOAD.LOAD_BOR');
2655: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2656: MSC_CL_BOM_ODS_LOAD.LOAD_BOR;
2657:

Line 2654: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_BOM_ODS_LOAD.LOAD_BOR');

2650:
2651: ELSIF pTASKNUM= PTASK_BOR THEN
2652:
2653: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2654: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_BOM_ODS_LOAD.LOAD_BOR');
2655: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2656: MSC_CL_BOM_ODS_LOAD.LOAD_BOR;
2657:
2658: ELSIF pTASKNUM= PTASK_CALENDAR_DATE THEN

Line 2655: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

2651: ELSIF pTASKNUM= PTASK_BOR THEN
2652:
2653: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2654: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_BOM_ODS_LOAD.LOAD_BOR');
2655: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2656: MSC_CL_BOM_ODS_LOAD.LOAD_BOR;
2657:
2658: ELSIF pTASKNUM= PTASK_CALENDAR_DATE THEN
2659:

Line 2660: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');

2656: MSC_CL_BOM_ODS_LOAD.LOAD_BOR;
2657:
2658: ELSIF pTASKNUM= PTASK_CALENDAR_DATE THEN
2659:
2660: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2661: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SETUP_ODS_LOAD.LOAD_CALENDAR_DATE');
2662: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2663: MSC_CL_SETUP_ODS_LOAD.LOAD_CALENDAR_DATE;
2664:

Line 2661: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SETUP_ODS_LOAD.LOAD_CALENDAR_DATE');

2657:
2658: ELSIF pTASKNUM= PTASK_CALENDAR_DATE THEN
2659:
2660: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2661: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SETUP_ODS_LOAD.LOAD_CALENDAR_DATE');
2662: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2663: MSC_CL_SETUP_ODS_LOAD.LOAD_CALENDAR_DATE;
2664:
2665: ELSIF pTASKNUM= PTASK_DEMAND_CLASS THEN

Line 2662: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

2658: ELSIF pTASKNUM= PTASK_CALENDAR_DATE THEN
2659:
2660: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2661: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SETUP_ODS_LOAD.LOAD_CALENDAR_DATE');
2662: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2663: MSC_CL_SETUP_ODS_LOAD.LOAD_CALENDAR_DATE;
2664:
2665: ELSIF pTASKNUM= PTASK_DEMAND_CLASS THEN
2666:

Line 2667: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');

2663: MSC_CL_SETUP_ODS_LOAD.LOAD_CALENDAR_DATE;
2664:
2665: ELSIF pTASKNUM= PTASK_DEMAND_CLASS THEN
2666:
2667: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2668: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_DEMAND_CLASS');
2669: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2670: MSC_CL_OTHER_ODS_LOAD.LOAD_DEMAND_CLASS;
2671:

Line 2668: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_DEMAND_CLASS');

2664:
2665: ELSIF pTASKNUM= PTASK_DEMAND_CLASS THEN
2666:
2667: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2668: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_DEMAND_CLASS');
2669: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2670: MSC_CL_OTHER_ODS_LOAD.LOAD_DEMAND_CLASS;
2671:
2672: ELSIF pTASKNUM= PTASK_DESIGNATOR THEN

Line 2669: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

2665: ELSIF pTASKNUM= PTASK_DEMAND_CLASS THEN
2666:
2667: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2668: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_DEMAND_CLASS');
2669: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2670: MSC_CL_OTHER_ODS_LOAD.LOAD_DEMAND_CLASS;
2671:
2672: ELSIF pTASKNUM= PTASK_DESIGNATOR THEN
2673:

Line 2674: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');

2670: MSC_CL_OTHER_ODS_LOAD.LOAD_DEMAND_CLASS;
2671:
2672: ELSIF pTASKNUM= PTASK_DESIGNATOR THEN
2673:
2674: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2675: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LOAD_DESIGNATOR');
2676: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2677: MSC_CL_DEMAND_ODS_LOAD.LOAD_DESIGNATOR;
2678:

Line 2675: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LOAD_DESIGNATOR');

2671:
2672: ELSIF pTASKNUM= PTASK_DESIGNATOR THEN
2673:
2674: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2675: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LOAD_DESIGNATOR');
2676: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2677: MSC_CL_DEMAND_ODS_LOAD.LOAD_DESIGNATOR;
2678:
2679: ELSIF pTASKNUM= PTASK_BIS_PFMC_MEASURES THEN

Line 2676: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

2672: ELSIF pTASKNUM= PTASK_DESIGNATOR THEN
2673:
2674: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2675: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LOAD_DESIGNATOR');
2676: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2677: MSC_CL_DEMAND_ODS_LOAD.LOAD_DESIGNATOR;
2678:
2679: ELSIF pTASKNUM= PTASK_BIS_PFMC_MEASURES THEN
2680:

Line 2682: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');

2678:
2679: ELSIF pTASKNUM= PTASK_BIS_PFMC_MEASURES THEN
2680:
2681: IF v_apps_ver <> MSC_UTIL.G_APPS107 THEN
2682: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2683: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_BIS_PFMC_MEASURES');
2684: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2685: MSC_CL_OTHER_ODS_LOAD.LOAD_BIS_PFMC_MEASURES;
2686: END IF;

Line 2683: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_BIS_PFMC_MEASURES');

2679: ELSIF pTASKNUM= PTASK_BIS_PFMC_MEASURES THEN
2680:
2681: IF v_apps_ver <> MSC_UTIL.G_APPS107 THEN
2682: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2683: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_BIS_PFMC_MEASURES');
2684: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2685: MSC_CL_OTHER_ODS_LOAD.LOAD_BIS_PFMC_MEASURES;
2686: END IF;
2687:

Line 2684: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

2680:
2681: IF v_apps_ver <> MSC_UTIL.G_APPS107 THEN
2682: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2683: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_BIS_PFMC_MEASURES');
2684: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2685: MSC_CL_OTHER_ODS_LOAD.LOAD_BIS_PFMC_MEASURES;
2686: END IF;
2687:
2688: ELSIF pTASKNUM= PTASK_BIS_TARGET_LEVELS THEN

Line 2691: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');

2687:
2688: ELSIF pTASKNUM= PTASK_BIS_TARGET_LEVELS THEN
2689:
2690: IF v_apps_ver <> MSC_UTIL.G_APPS107 THEN
2691: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2692: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_BIS_TARGET_LEVELS');
2693: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2694: MSC_CL_OTHER_ODS_LOAD.LOAD_BIS_TARGET_LEVELS;
2695: END IF;

Line 2692: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_BIS_TARGET_LEVELS');

2688: ELSIF pTASKNUM= PTASK_BIS_TARGET_LEVELS THEN
2689:
2690: IF v_apps_ver <> MSC_UTIL.G_APPS107 THEN
2691: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2692: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_BIS_TARGET_LEVELS');
2693: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2694: MSC_CL_OTHER_ODS_LOAD.LOAD_BIS_TARGET_LEVELS;
2695: END IF;
2696:

Line 2693: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

2689:
2690: IF v_apps_ver <> MSC_UTIL.G_APPS107 THEN
2691: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2692: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_BIS_TARGET_LEVELS');
2693: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2694: MSC_CL_OTHER_ODS_LOAD.LOAD_BIS_TARGET_LEVELS;
2695: END IF;
2696:
2697: ELSIF pTASKNUM= PTASK_BIS_TARGETS THEN

Line 2700: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');

2696:
2697: ELSIF pTASKNUM= PTASK_BIS_TARGETS THEN
2698:
2699: IF v_apps_ver <> MSC_UTIL.G_APPS107 THEN
2700: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2701: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_BIS_TARGETS');
2702: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2703: MSC_CL_OTHER_ODS_LOAD.LOAD_BIS_TARGETS;
2704: END IF;

Line 2701: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_BIS_TARGETS');

2697: ELSIF pTASKNUM= PTASK_BIS_TARGETS THEN
2698:
2699: IF v_apps_ver <> MSC_UTIL.G_APPS107 THEN
2700: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2701: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_BIS_TARGETS');
2702: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2703: MSC_CL_OTHER_ODS_LOAD.LOAD_BIS_TARGETS;
2704: END IF;
2705:

Line 2702: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

2698:
2699: IF v_apps_ver <> MSC_UTIL.G_APPS107 THEN
2700: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2701: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_BIS_TARGETS');
2702: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2703: MSC_CL_OTHER_ODS_LOAD.LOAD_BIS_TARGETS;
2704: END IF;
2705:
2706: ELSIF pTASKNUM= PTASK_BIS_BUSINESS_PLANS THEN

Line 2709: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');

2705:
2706: ELSIF pTASKNUM= PTASK_BIS_BUSINESS_PLANS THEN
2707:
2708: IF v_apps_ver <> MSC_UTIL.G_APPS107 THEN
2709: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2710: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_BIS_BUSINESS_PLANS');
2711: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2712: MSC_CL_OTHER_ODS_LOAD.LOAD_BIS_BUSINESS_PLANS;
2713: END IF;

Line 2710: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_BIS_BUSINESS_PLANS');

2706: ELSIF pTASKNUM= PTASK_BIS_BUSINESS_PLANS THEN
2707:
2708: IF v_apps_ver <> MSC_UTIL.G_APPS107 THEN
2709: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2710: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_BIS_BUSINESS_PLANS');
2711: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2712: MSC_CL_OTHER_ODS_LOAD.LOAD_BIS_BUSINESS_PLANS;
2713: END IF;
2714:

Line 2711: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

2707:
2708: IF v_apps_ver <> MSC_UTIL.G_APPS107 THEN
2709: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2710: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_BIS_BUSINESS_PLANS');
2711: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2712: MSC_CL_OTHER_ODS_LOAD.LOAD_BIS_BUSINESS_PLANS;
2713: END IF;
2714:
2715: ELSIF pTASKNUM= PTASK_BIS_PERIODS THEN

Line 2717: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');

2713: END IF;
2714:
2715: ELSIF pTASKNUM= PTASK_BIS_PERIODS THEN
2716:
2717: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2718: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_BIS_PERIODS');
2719: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2720: MSC_CL_OTHER_ODS_LOAD.LOAD_BIS_PERIODS;
2721:

Line 2718: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_BIS_PERIODS');

2714:
2715: ELSIF pTASKNUM= PTASK_BIS_PERIODS THEN
2716:
2717: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2718: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_BIS_PERIODS');
2719: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2720: MSC_CL_OTHER_ODS_LOAD.LOAD_BIS_PERIODS;
2721:
2722: ELSIF pTASKNUM= PTASK_PARAMETER THEN

Line 2719: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

2715: ELSIF pTASKNUM= PTASK_BIS_PERIODS THEN
2716:
2717: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2718: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_BIS_PERIODS');
2719: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2720: MSC_CL_OTHER_ODS_LOAD.LOAD_BIS_PERIODS;
2721:
2722: ELSIF pTASKNUM= PTASK_PARAMETER THEN
2723:

Line 2724: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');

2720: MSC_CL_OTHER_ODS_LOAD.LOAD_BIS_PERIODS;
2721:
2722: ELSIF pTASKNUM= PTASK_PARAMETER THEN
2723:
2724: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2725: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SETUP_ODS_LOAD.LOAD_PARAMETER');
2726: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2727: MSC_CL_SETUP_ODS_LOAD.LOAD_PARAMETER;
2728:

Line 2725: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SETUP_ODS_LOAD.LOAD_PARAMETER');

2721:
2722: ELSIF pTASKNUM= PTASK_PARAMETER THEN
2723:
2724: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2725: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SETUP_ODS_LOAD.LOAD_PARAMETER');
2726: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2727: MSC_CL_SETUP_ODS_LOAD.LOAD_PARAMETER;
2728:
2729: ELSIF pTASKNUM= PTASK_PLANNERS THEN

Line 2726: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

2722: ELSIF pTASKNUM= PTASK_PARAMETER THEN
2723:
2724: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2725: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SETUP_ODS_LOAD.LOAD_PARAMETER');
2726: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2727: MSC_CL_SETUP_ODS_LOAD.LOAD_PARAMETER;
2728:
2729: ELSIF pTASKNUM= PTASK_PLANNERS THEN
2730:

Line 2731: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');

2727: MSC_CL_SETUP_ODS_LOAD.LOAD_PARAMETER;
2728:
2729: ELSIF pTASKNUM= PTASK_PLANNERS THEN
2730:
2731: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2732: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_PLANNERS');
2733: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2734: MSC_CL_OTHER_ODS_LOAD.LOAD_PLANNERS;
2735:

Line 2732: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_PLANNERS');

2728:
2729: ELSIF pTASKNUM= PTASK_PLANNERS THEN
2730:
2731: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2732: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_PLANNERS');
2733: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2734: MSC_CL_OTHER_ODS_LOAD.LOAD_PLANNERS;
2735:
2736: ELSIF pTASKNUM= PTASK_PROJECT THEN

Line 2733: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

2729: ELSIF pTASKNUM= PTASK_PLANNERS THEN
2730:
2731: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2732: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_PLANNERS');
2733: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2734: MSC_CL_OTHER_ODS_LOAD.LOAD_PLANNERS;
2735:
2736: ELSIF pTASKNUM= PTASK_PROJECT THEN
2737:

Line 2738: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');

2734: MSC_CL_OTHER_ODS_LOAD.LOAD_PLANNERS;
2735:
2736: ELSIF pTASKNUM= PTASK_PROJECT THEN
2737:
2738: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2739: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_PROJECT');
2740: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2741: MSC_CL_OTHER_ODS_LOAD.LOAD_PROJECT;
2742:

Line 2739: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_PROJECT');

2735:
2736: ELSIF pTASKNUM= PTASK_PROJECT THEN
2737:
2738: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2739: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_PROJECT');
2740: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2741: MSC_CL_OTHER_ODS_LOAD.LOAD_PROJECT;
2742:
2743: ELSIF pTASKNUM= PTASK_SUB_INVENTORY THEN

Line 2740: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

2736: ELSIF pTASKNUM= PTASK_PROJECT THEN
2737:
2738: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2739: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_PROJECT');
2740: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2741: MSC_CL_OTHER_ODS_LOAD.LOAD_PROJECT;
2742:
2743: ELSIF pTASKNUM= PTASK_SUB_INVENTORY THEN
2744:

Line 2745: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');

2741: MSC_CL_OTHER_ODS_LOAD.LOAD_PROJECT;
2742:
2743: ELSIF pTASKNUM= PTASK_SUB_INVENTORY THEN
2744:
2745: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2746: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_SUB_INVENTORY');
2747: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2748: MSC_CL_OTHER_ODS_LOAD.LOAD_SUB_INVENTORY;
2749:

Line 2746: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_SUB_INVENTORY');

2742:
2743: ELSIF pTASKNUM= PTASK_SUB_INVENTORY THEN
2744:
2745: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2746: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_SUB_INVENTORY');
2747: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2748: MSC_CL_OTHER_ODS_LOAD.LOAD_SUB_INVENTORY;
2749:
2750: ELSIF pTASKNUM= PTASK_UNIT_NUMBER THEN

Line 2747: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

2743: ELSIF pTASKNUM= PTASK_SUB_INVENTORY THEN
2744:
2745: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2746: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_SUB_INVENTORY');
2747: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2748: MSC_CL_OTHER_ODS_LOAD.LOAD_SUB_INVENTORY;
2749:
2750: ELSIF pTASKNUM= PTASK_UNIT_NUMBER THEN
2751:

Line 2752: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');

2748: MSC_CL_OTHER_ODS_LOAD.LOAD_SUB_INVENTORY;
2749:
2750: ELSIF pTASKNUM= PTASK_UNIT_NUMBER THEN
2751:
2752: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2753: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_UNIT_NUMBER');
2754: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2755: MSC_CL_OTHER_ODS_LOAD.LOAD_UNIT_NUMBER;
2756:

Line 2753: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_UNIT_NUMBER');

2749:
2750: ELSIF pTASKNUM= PTASK_UNIT_NUMBER THEN
2751:
2752: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2753: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_UNIT_NUMBER');
2754: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2755: MSC_CL_OTHER_ODS_LOAD.LOAD_UNIT_NUMBER;
2756:
2757: ELSIF pTASKNUM = PTASK_ITEM_SUBSTITUTES THEN

Line 2754: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

2750: ELSIF pTASKNUM= PTASK_UNIT_NUMBER THEN
2751:
2752: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2753: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_UNIT_NUMBER');
2754: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2755: MSC_CL_OTHER_ODS_LOAD.LOAD_UNIT_NUMBER;
2756:
2757: ELSIF pTASKNUM = PTASK_ITEM_SUBSTITUTES THEN
2758:

Line 2760: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');

2756:
2757: ELSIF pTASKNUM = PTASK_ITEM_SUBSTITUTES THEN
2758:
2759: IF v_apps_ver <> MSC_UTIL.G_APPS107 THEN
2760: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
2761: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ITEM_ODS_LOAD.LOAD_ITEM_SUBSTITUTES');
2762: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2763: MSC_CL_ITEM_ODS_LOAD.LOAD_ITEM_SUBSTITUTES;
2764: END IF;

Line 2761: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ITEM_ODS_LOAD.LOAD_ITEM_SUBSTITUTES');

2757: ELSIF pTASKNUM = PTASK_ITEM_SUBSTITUTES THEN
2758:
2759: IF v_apps_ver <> MSC_UTIL.G_APPS107 THEN
2760: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
2761: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ITEM_ODS_LOAD.LOAD_ITEM_SUBSTITUTES');
2762: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2763: MSC_CL_ITEM_ODS_LOAD.LOAD_ITEM_SUBSTITUTES;
2764: END IF;
2765:

Line 2762: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

2758:
2759: IF v_apps_ver <> MSC_UTIL.G_APPS107 THEN
2760: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
2761: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ITEM_ODS_LOAD.LOAD_ITEM_SUBSTITUTES');
2762: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2763: MSC_CL_ITEM_ODS_LOAD.LOAD_ITEM_SUBSTITUTES;
2764: END IF;
2765:
2766: ELSIF pTASKNUM= PTASK_ITEM_CUSTOMERS THEN

Line 2768: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');

2764: END IF;
2765:
2766: ELSIF pTASKNUM= PTASK_ITEM_CUSTOMERS THEN
2767:
2768: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2769: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'TASK_ITEM_CUSTOMERS');
2770: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2771: MSC_CL_SCE_COLLECTION.LOAD_ITEM_CUSTOMERS(v_instance_id);
2772:

Line 2769: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'TASK_ITEM_CUSTOMERS');

2765:
2766: ELSIF pTASKNUM= PTASK_ITEM_CUSTOMERS THEN
2767:
2768: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2769: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'TASK_ITEM_CUSTOMERS');
2770: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2771: MSC_CL_SCE_COLLECTION.LOAD_ITEM_CUSTOMERS(v_instance_id);
2772:
2773: ELSIF pTASKNUM= PTASK_COMPANY_USERS THEN

Line 2770: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

2766: ELSIF pTASKNUM= PTASK_ITEM_CUSTOMERS THEN
2767:
2768: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2769: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'TASK_ITEM_CUSTOMERS');
2770: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2771: MSC_CL_SCE_COLLECTION.LOAD_ITEM_CUSTOMERS(v_instance_id);
2772:
2773: ELSIF pTASKNUM= PTASK_COMPANY_USERS THEN
2774:

Line 2780: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');

2776: 'APS + SCE' or 'SCE. */
2777: IF (MSC_UTIL.G_MSC_CONFIGURATION = MSC_UTIL.G_CONF_APS_SCE
2778: OR MSC_UTIL.G_MSC_CONFIGURATION = MSC_UTIL.G_CONF_SCE) THEN
2779:
2780: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
2781: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SCE_COLLECTION.LOAD_USER_COMPANY');
2782: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2783: MSC_CL_SCE_COLLECTION.LOAD_USER_COMPANY(v_instance_id);
2784:

Line 2781: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SCE_COLLECTION.LOAD_USER_COMPANY');

2777: IF (MSC_UTIL.G_MSC_CONFIGURATION = MSC_UTIL.G_CONF_APS_SCE
2778: OR MSC_UTIL.G_MSC_CONFIGURATION = MSC_UTIL.G_CONF_SCE) THEN
2779:
2780: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
2781: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SCE_COLLECTION.LOAD_USER_COMPANY');
2782: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2783: MSC_CL_SCE_COLLECTION.LOAD_USER_COMPANY(v_instance_id);
2784:
2785: END IF;

Line 2782: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

2778: OR MSC_UTIL.G_MSC_CONFIGURATION = MSC_UTIL.G_CONF_SCE) THEN
2779:
2780: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
2781: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SCE_COLLECTION.LOAD_USER_COMPANY');
2782: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2783: MSC_CL_SCE_COLLECTION.LOAD_USER_COMPANY(v_instance_id);
2784:
2785: END IF;
2786: /* SCE Change ends */

Line 2792: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');

2788: ELSIF pTASKNUM= PTASK_TRIP THEN
2789:
2790: IF (v_apps_ver >= MSC_UTIL.G_APPS115) OR v_is_legacy_refresh THEN
2791:
2792: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2793: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_TRIP');
2794: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2795: MSC_CL_OTHER_ODS_LOAD.LOAD_TRIP;
2796:

Line 2793: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_TRIP');

2789:
2790: IF (v_apps_ver >= MSC_UTIL.G_APPS115) OR v_is_legacy_refresh THEN
2791:
2792: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2793: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_TRIP');
2794: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2795: MSC_CL_OTHER_ODS_LOAD.LOAD_TRIP;
2796:
2797: END IF;

Line 2794: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

2790: IF (v_apps_ver >= MSC_UTIL.G_APPS115) OR v_is_legacy_refresh THEN
2791:
2792: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2793: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_TRIP');
2794: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2795: MSC_CL_OTHER_ODS_LOAD.LOAD_TRIP;
2796:
2797: END IF;
2798:

Line 2802: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');

2798:
2799: /*ds change start */
2800: ELSIF pTASKNUM = PTASK_RES_INST_REQ THEN
2801: IF MSC_CL_SUPPLY_ODS_LOAD.IS_SUPPLIES_LOAD_DONE THEN
2802: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2803: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_WIP_ODS_LOAD.LOAD_RES_INST_REQ');
2804: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2805: MSC_CL_WIP_ODS_LOAD.LOAD_RES_INST_REQ;
2806: ELSE

Line 2803: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_WIP_ODS_LOAD.LOAD_RES_INST_REQ');

2799: /*ds change start */
2800: ELSIF pTASKNUM = PTASK_RES_INST_REQ THEN
2801: IF MSC_CL_SUPPLY_ODS_LOAD.IS_SUPPLIES_LOAD_DONE THEN
2802: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2803: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_WIP_ODS_LOAD.LOAD_RES_INST_REQ');
2804: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2805: MSC_CL_WIP_ODS_LOAD.LOAD_RES_INST_REQ;
2806: ELSE
2807: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, 'Loading of Supplies failed.PTASK_RES_INST_REQ');

Line 2804: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

2800: ELSIF pTASKNUM = PTASK_RES_INST_REQ THEN
2801: IF MSC_CL_SUPPLY_ODS_LOAD.IS_SUPPLIES_LOAD_DONE THEN
2802: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2803: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_WIP_ODS_LOAD.LOAD_RES_INST_REQ');
2804: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2805: MSC_CL_WIP_ODS_LOAD.LOAD_RES_INST_REQ;
2806: ELSE
2807: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, 'Loading of Supplies failed.PTASK_RES_INST_REQ');
2808: RAISE SUPPLIES_LOAD_FAIL;

Line 2814: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');

2810: ELSIF pTASKNUM= PTASK_RESOURCE_SETUP THEN
2811:
2812: IF (v_apps_ver >= MSC_UTIL.G_APPS115) OR v_is_legacy_refresh THEN
2813:
2814: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2815: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_BOM_ODS_LOAD.LOAD_RESOURCE_SETUP');
2816: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2817: MSC_CL_BOM_ODS_LOAD.LOAD_RESOURCE_SETUP;
2818:

Line 2815: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_BOM_ODS_LOAD.LOAD_RESOURCE_SETUP');

2811:
2812: IF (v_apps_ver >= MSC_UTIL.G_APPS115) OR v_is_legacy_refresh THEN
2813:
2814: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2815: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_BOM_ODS_LOAD.LOAD_RESOURCE_SETUP');
2816: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2817: MSC_CL_BOM_ODS_LOAD.LOAD_RESOURCE_SETUP;
2818:
2819: END IF;

Line 2816: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

2812: IF (v_apps_ver >= MSC_UTIL.G_APPS115) OR v_is_legacy_refresh THEN
2813:
2814: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2815: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_BOM_ODS_LOAD.LOAD_RESOURCE_SETUP');
2816: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2817: MSC_CL_BOM_ODS_LOAD.LOAD_RESOURCE_SETUP;
2818:
2819: END IF;
2820: ELSIF pTASKNUM= PTASK_SETUP_TRANSITION THEN

Line 2824: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');

2820: ELSIF pTASKNUM= PTASK_SETUP_TRANSITION THEN
2821:
2822: IF (v_apps_ver >= MSC_UTIL.G_APPS115) OR v_is_legacy_refresh THEN
2823:
2824: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2825: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_BOM_ODS_LOAD.LOAD_SETUP_TRANSITION');
2826: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2827: MSC_CL_BOM_ODS_LOAD.LOAD_SETUP_TRANSITION;
2828:

Line 2825: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_BOM_ODS_LOAD.LOAD_SETUP_TRANSITION');

2821:
2822: IF (v_apps_ver >= MSC_UTIL.G_APPS115) OR v_is_legacy_refresh THEN
2823:
2824: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2825: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_BOM_ODS_LOAD.LOAD_SETUP_TRANSITION');
2826: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2827: MSC_CL_BOM_ODS_LOAD.LOAD_SETUP_TRANSITION;
2828:
2829: END IF;

Line 2826: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

2822: IF (v_apps_ver >= MSC_UTIL.G_APPS115) OR v_is_legacy_refresh THEN
2823:
2824: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2825: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_BOM_ODS_LOAD.LOAD_SETUP_TRANSITION');
2826: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2827: MSC_CL_BOM_ODS_LOAD.LOAD_SETUP_TRANSITION;
2828:
2829: END IF;
2830: ELSIF pTASKNUM= PTASK_STD_OP_RESOURCES THEN

Line 2834: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');

2830: ELSIF pTASKNUM= PTASK_STD_OP_RESOURCES THEN
2831:
2832: IF (v_apps_ver >= MSC_UTIL.G_APPS115) OR v_is_legacy_refresh THEN
2833:
2834: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2835: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ROUTING_ODS_LOAD.LOAD_STD_OP_RESOURCES');
2836: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2837: MSC_CL_ROUTING_ODS_LOAD.LOAD_STD_OP_RESOURCES;
2838:

Line 2835: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ROUTING_ODS_LOAD.LOAD_STD_OP_RESOURCES');

2831:
2832: IF (v_apps_ver >= MSC_UTIL.G_APPS115) OR v_is_legacy_refresh THEN
2833:
2834: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2835: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ROUTING_ODS_LOAD.LOAD_STD_OP_RESOURCES');
2836: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2837: MSC_CL_ROUTING_ODS_LOAD.LOAD_STD_OP_RESOURCES;
2838:
2839: END IF;

Line 2836: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

2832: IF (v_apps_ver >= MSC_UTIL.G_APPS115) OR v_is_legacy_refresh THEN
2833:
2834: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2835: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ROUTING_ODS_LOAD.LOAD_STD_OP_RESOURCES');
2836: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2837: MSC_CL_ROUTING_ODS_LOAD.LOAD_STD_OP_RESOURCES;
2838:
2839: END IF;
2840:

Line 2846: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');

2842:
2843: ELSIF pTASKNUM= PTASK_SALES_CHANNEL THEN
2844:
2845: IF (v_apps_ver >= MSC_UTIL.G_APPS115) THEN
2846: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2847: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_SALES_CHANNEL');
2848: -- LOG_MESSAGE(FND_MESSAGE.GET);
2849: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2850: MSC_CL_OTHER_ODS_LOAD.LOAD_SALES_CHANNEL;

Line 2847: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_SALES_CHANNEL');

2843: ELSIF pTASKNUM= PTASK_SALES_CHANNEL THEN
2844:
2845: IF (v_apps_ver >= MSC_UTIL.G_APPS115) THEN
2846: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2847: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_SALES_CHANNEL');
2848: -- LOG_MESSAGE(FND_MESSAGE.GET);
2849: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2850: MSC_CL_OTHER_ODS_LOAD.LOAD_SALES_CHANNEL;
2851: END IF;

Line 2848: -- LOG_MESSAGE(FND_MESSAGE.GET);

2844:
2845: IF (v_apps_ver >= MSC_UTIL.G_APPS115) THEN
2846: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2847: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_SALES_CHANNEL');
2848: -- LOG_MESSAGE(FND_MESSAGE.GET);
2849: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2850: MSC_CL_OTHER_ODS_LOAD.LOAD_SALES_CHANNEL;
2851: END IF;
2852: ELSIF pTASKNUM= PTASK_FISCAL_CALENDAR THEN

Line 2849: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

2845: IF (v_apps_ver >= MSC_UTIL.G_APPS115) THEN
2846: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2847: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_SALES_CHANNEL');
2848: -- LOG_MESSAGE(FND_MESSAGE.GET);
2849: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2850: MSC_CL_OTHER_ODS_LOAD.LOAD_SALES_CHANNEL;
2851: END IF;
2852: ELSIF pTASKNUM= PTASK_FISCAL_CALENDAR THEN
2853: IF (v_apps_ver >= MSC_UTIL.G_APPS115) THEN

Line 2854: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');

2850: MSC_CL_OTHER_ODS_LOAD.LOAD_SALES_CHANNEL;
2851: END IF;
2852: ELSIF pTASKNUM= PTASK_FISCAL_CALENDAR THEN
2853: IF (v_apps_ver >= MSC_UTIL.G_APPS115) THEN
2854: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2855: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_FISCAL_CALENDAR');
2856: -- LOG_MESSAGE(FND_MESSAGE.GET);
2857: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2858: MSC_CL_OTHER_ODS_LOAD.LOAD_FISCAL_CALENDAR;

Line 2855: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_FISCAL_CALENDAR');

2851: END IF;
2852: ELSIF pTASKNUM= PTASK_FISCAL_CALENDAR THEN
2853: IF (v_apps_ver >= MSC_UTIL.G_APPS115) THEN
2854: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2855: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_FISCAL_CALENDAR');
2856: -- LOG_MESSAGE(FND_MESSAGE.GET);
2857: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2858: MSC_CL_OTHER_ODS_LOAD.LOAD_FISCAL_CALENDAR;
2859: END IF;

Line 2856: -- LOG_MESSAGE(FND_MESSAGE.GET);

2852: ELSIF pTASKNUM= PTASK_FISCAL_CALENDAR THEN
2853: IF (v_apps_ver >= MSC_UTIL.G_APPS115) THEN
2854: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2855: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_FISCAL_CALENDAR');
2856: -- LOG_MESSAGE(FND_MESSAGE.GET);
2857: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2858: MSC_CL_OTHER_ODS_LOAD.LOAD_FISCAL_CALENDAR;
2859: END IF;
2860: ELSIF pTASKNUM= PTASK_PAYBACK_DEMAND_SUPPLY THEN --bug 5861050

Line 2857: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

2853: IF (v_apps_ver >= MSC_UTIL.G_APPS115) THEN
2854: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2855: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_FISCAL_CALENDAR');
2856: -- LOG_MESSAGE(FND_MESSAGE.GET);
2857: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2858: MSC_CL_OTHER_ODS_LOAD.LOAD_FISCAL_CALENDAR;
2859: END IF;
2860: ELSIF pTASKNUM= PTASK_PAYBACK_DEMAND_SUPPLY THEN --bug 5861050
2861:

Line 2862: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');

2858: MSC_CL_OTHER_ODS_LOAD.LOAD_FISCAL_CALENDAR;
2859: END IF;
2860: ELSIF pTASKNUM= PTASK_PAYBACK_DEMAND_SUPPLY THEN --bug 5861050
2861:
2862: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2863: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LOAD_PAYBACK_DEMANDS');
2864: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS,FND_MESSAGE.GET);
2865: MSC_CL_DEMAND_ODS_LOAD.LOAD_PAYBACK_DEMANDS;
2866:

Line 2863: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LOAD_PAYBACK_DEMANDS');

2859: END IF;
2860: ELSIF pTASKNUM= PTASK_PAYBACK_DEMAND_SUPPLY THEN --bug 5861050
2861:
2862: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2863: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LOAD_PAYBACK_DEMANDS');
2864: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS,FND_MESSAGE.GET);
2865: MSC_CL_DEMAND_ODS_LOAD.LOAD_PAYBACK_DEMANDS;
2866:
2867: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');

Line 2864: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS,FND_MESSAGE.GET);

2860: ELSIF pTASKNUM= PTASK_PAYBACK_DEMAND_SUPPLY THEN --bug 5861050
2861:
2862: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2863: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LOAD_PAYBACK_DEMANDS');
2864: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS,FND_MESSAGE.GET);
2865: MSC_CL_DEMAND_ODS_LOAD.LOAD_PAYBACK_DEMANDS;
2866:
2867: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2868: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SUPPLY_ODS_LOAD.LOAD_PAYBACK_SUPPLIES');

Line 2867: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');

2863: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LOAD_PAYBACK_DEMANDS');
2864: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS,FND_MESSAGE.GET);
2865: MSC_CL_DEMAND_ODS_LOAD.LOAD_PAYBACK_DEMANDS;
2866:
2867: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2868: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SUPPLY_ODS_LOAD.LOAD_PAYBACK_SUPPLIES');
2869: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS,FND_MESSAGE.GET);
2870: MSC_CL_SUPPLY_ODS_LOAD.LOAD_PAYBACK_SUPPLIES;
2871:

Line 2868: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SUPPLY_ODS_LOAD.LOAD_PAYBACK_SUPPLIES');

2864: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS,FND_MESSAGE.GET);
2865: MSC_CL_DEMAND_ODS_LOAD.LOAD_PAYBACK_DEMANDS;
2866:
2867: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2868: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SUPPLY_ODS_LOAD.LOAD_PAYBACK_SUPPLIES');
2869: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS,FND_MESSAGE.GET);
2870: MSC_CL_SUPPLY_ODS_LOAD.LOAD_PAYBACK_SUPPLIES;
2871:
2872: ELSIF pTASKNUM= PTASK_DELIVERY_DETAILS THEN

Line 2869: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS,FND_MESSAGE.GET);

2865: MSC_CL_DEMAND_ODS_LOAD.LOAD_PAYBACK_DEMANDS;
2866:
2867: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2868: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SUPPLY_ODS_LOAD.LOAD_PAYBACK_SUPPLIES');
2869: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS,FND_MESSAGE.GET);
2870: MSC_CL_SUPPLY_ODS_LOAD.LOAD_PAYBACK_SUPPLIES;
2871:
2872: ELSIF pTASKNUM= PTASK_DELIVERY_DETAILS THEN
2873: IF (v_apps_ver >= MSC_UTIL.G_APPS120) THEN

Line 2874: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');

2870: MSC_CL_SUPPLY_ODS_LOAD.LOAD_PAYBACK_SUPPLIES;
2871:
2872: ELSIF pTASKNUM= PTASK_DELIVERY_DETAILS THEN
2873: IF (v_apps_ver >= MSC_UTIL.G_APPS120) THEN
2874: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2875: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_DELIVERY_DETAILS');
2876: -- LOG_MESSAGE(FND_MESSAGE.GET);
2877: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2878: MSC_CL_OTHER_ODS_LOAD.LOAD_DELIVERY_DETAILS;

Line 2875: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_DELIVERY_DETAILS');

2871:
2872: ELSIF pTASKNUM= PTASK_DELIVERY_DETAILS THEN
2873: IF (v_apps_ver >= MSC_UTIL.G_APPS120) THEN
2874: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2875: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_DELIVERY_DETAILS');
2876: -- LOG_MESSAGE(FND_MESSAGE.GET);
2877: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2878: MSC_CL_OTHER_ODS_LOAD.LOAD_DELIVERY_DETAILS;
2879: END IF;

Line 2876: -- LOG_MESSAGE(FND_MESSAGE.GET);

2872: ELSIF pTASKNUM= PTASK_DELIVERY_DETAILS THEN
2873: IF (v_apps_ver >= MSC_UTIL.G_APPS120) THEN
2874: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2875: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_DELIVERY_DETAILS');
2876: -- LOG_MESSAGE(FND_MESSAGE.GET);
2877: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2878: MSC_CL_OTHER_ODS_LOAD.LOAD_DELIVERY_DETAILS;
2879: END IF;
2880:

Line 2877: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

2873: IF (v_apps_ver >= MSC_UTIL.G_APPS120) THEN
2874: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2875: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_DELIVERY_DETAILS');
2876: -- LOG_MESSAGE(FND_MESSAGE.GET);
2877: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2878: MSC_CL_OTHER_ODS_LOAD.LOAD_DELIVERY_DETAILS;
2879: END IF;
2880:
2881: ELSIF pTASKNUM= PTASK_CURRENCY_CONVERSION THEN -- for bug # 6469722

Line 2882: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');

2878: MSC_CL_OTHER_ODS_LOAD.LOAD_DELIVERY_DETAILS;
2879: END IF;
2880:
2881: ELSIF pTASKNUM= PTASK_CURRENCY_CONVERSION THEN -- for bug # 6469722
2882: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2883: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_CURRENCY_CONVERSION');
2884: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2885:
2886: IF (MSC_CL_OTHER_PULL.G_MSC_HUB_CURR_CODE IS NOT NULL) AND (v_apps_ver >= MSC_UTIL.G_APPS115) THEN

Line 2883: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_CURRENCY_CONVERSION');

2879: END IF;
2880:
2881: ELSIF pTASKNUM= PTASK_CURRENCY_CONVERSION THEN -- for bug # 6469722
2882: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2883: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_CURRENCY_CONVERSION');
2884: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2885:
2886: IF (MSC_CL_OTHER_PULL.G_MSC_HUB_CURR_CODE IS NOT NULL) AND (v_apps_ver >= MSC_UTIL.G_APPS115) THEN
2887: MSC_CL_OTHER_ODS_LOAD.LOAD_CURRENCY_CONVERSION;

Line 2884: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

2880:
2881: ELSIF pTASKNUM= PTASK_CURRENCY_CONVERSION THEN -- for bug # 6469722
2882: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2883: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_CURRENCY_CONVERSION');
2884: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2885:
2886: IF (MSC_CL_OTHER_PULL.G_MSC_HUB_CURR_CODE IS NOT NULL) AND (v_apps_ver >= MSC_UTIL.G_APPS115) THEN
2887: MSC_CL_OTHER_ODS_LOAD.LOAD_CURRENCY_CONVERSION;
2888: ELSE

Line 2895: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');

2891:
2892: ELSIF pTASKNUM= PTASK_IRO_DEMAND THEN
2893: IF NOT(v_is_cont_refresh) THEN
2894: IF MSC_CL_SUPPLY_ODS_LOAD.IS_SUPPLIES_LOAD_DONE THEN
2895: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
2896: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_RPO_ODS_LOAD.LOAD_IRO_DEMAND');
2897: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2898: MSC_CL_RPO_ODS_LOAD.LOAD_IRO_DEMAND;
2899: END IF;

Line 2896: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_RPO_ODS_LOAD.LOAD_IRO_DEMAND');

2892: ELSIF pTASKNUM= PTASK_IRO_DEMAND THEN
2893: IF NOT(v_is_cont_refresh) THEN
2894: IF MSC_CL_SUPPLY_ODS_LOAD.IS_SUPPLIES_LOAD_DONE THEN
2895: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
2896: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_RPO_ODS_LOAD.LOAD_IRO_DEMAND');
2897: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2898: MSC_CL_RPO_ODS_LOAD.LOAD_IRO_DEMAND;
2899: END IF;
2900: END IF;

Line 2897: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

2893: IF NOT(v_is_cont_refresh) THEN
2894: IF MSC_CL_SUPPLY_ODS_LOAD.IS_SUPPLIES_LOAD_DONE THEN
2895: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
2896: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_RPO_ODS_LOAD.LOAD_IRO_DEMAND');
2897: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2898: MSC_CL_RPO_ODS_LOAD.LOAD_IRO_DEMAND;
2899: END IF;
2900: END IF;
2901: ELSIF pTASKNUM= PTASK_ERO_DEMAND THEN

Line 2904: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');

2900: END IF;
2901: ELSIF pTASKNUM= PTASK_ERO_DEMAND THEN
2902: IF NOT(v_is_cont_refresh) THEN
2903: IF MSC_CL_SUPPLY_ODS_LOAD.IS_SUPPLIES_LOAD_DONE THEN
2904: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
2905: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_RPO_ODS_LOAD.LOAD_ERO_DEMAND');
2906: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2907: MSC_CL_RPO_ODS_LOAD.LOAD_ERO_DEMAND;
2908: END IF;

Line 2905: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_RPO_ODS_LOAD.LOAD_ERO_DEMAND');

2901: ELSIF pTASKNUM= PTASK_ERO_DEMAND THEN
2902: IF NOT(v_is_cont_refresh) THEN
2903: IF MSC_CL_SUPPLY_ODS_LOAD.IS_SUPPLIES_LOAD_DONE THEN
2904: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
2905: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_RPO_ODS_LOAD.LOAD_ERO_DEMAND');
2906: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2907: MSC_CL_RPO_ODS_LOAD.LOAD_ERO_DEMAND;
2908: END IF;
2909: END IF;

Line 2906: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

2902: IF NOT(v_is_cont_refresh) THEN
2903: IF MSC_CL_SUPPLY_ODS_LOAD.IS_SUPPLIES_LOAD_DONE THEN
2904: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
2905: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_RPO_ODS_LOAD.LOAD_ERO_DEMAND');
2906: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2907: MSC_CL_RPO_ODS_LOAD.LOAD_ERO_DEMAND;
2908: END IF;
2909: END IF;
2910:

Line 2926: FND_MESSAGE.SET_NAME('MSC', 'MSC_ELAPSED_TIME');

2922: end if;
2923:
2924: pSTATUS := OK;
2925:
2926: FND_MESSAGE.SET_NAME('MSC', 'MSC_ELAPSED_TIME');
2927: FND_MESSAGE.SET_TOKEN('ELAPSED_TIME',
2928: TO_CHAR(CEIL((SYSDATE- lv_task_start_time)*14400.0)/10));
2929: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2930:

Line 2927: FND_MESSAGE.SET_TOKEN('ELAPSED_TIME',

2923:
2924: pSTATUS := OK;
2925:
2926: FND_MESSAGE.SET_NAME('MSC', 'MSC_ELAPSED_TIME');
2927: FND_MESSAGE.SET_TOKEN('ELAPSED_TIME',
2928: TO_CHAR(CEIL((SYSDATE- lv_task_start_time)*14400.0)/10));
2929: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2930:
2931: msc_util.print_top_wait(CEIL((SYSDATE- lv_task_start_time)*14400.0)/10);

Line 2929: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

2925:
2926: FND_MESSAGE.SET_NAME('MSC', 'MSC_ELAPSED_TIME');
2927: FND_MESSAGE.SET_TOKEN('ELAPSED_TIME',
2928: TO_CHAR(CEIL((SYSDATE- lv_task_start_time)*14400.0)/10));
2929: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2930:
2931: msc_util.print_top_wait(CEIL((SYSDATE- lv_task_start_time)*14400.0)/10);
2932: msc_util.print_cum_stat(CEIL((SYSDATE- lv_task_start_time)*14400.0)/10);
2933: msc_util.print_bad_sqls(CEIL((SYSDATE- lv_task_start_time)*14400.0)/10);

Line 3085: FND_MESSAGE.SET_NAME('MSC','MSC_CL_PURGE_BATCH_SIZE');

3081: v_monitor_request_id := pMONITOR_REQUEST_ID;
3082:
3083: --PBS := TO_NUMBER( FND_PROFILE.VALUE('MRP_PURGE_BATCH_SIZE'));
3084:
3085: FND_MESSAGE.SET_NAME('MSC','MSC_CL_PURGE_BATCH_SIZE');
3086: FND_MESSAGE.SET_TOKEN('PBS',PBS);
3087: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
3088:
3089: IF fnd_global.conc_request_id > 0 THEN

Line 3086: FND_MESSAGE.SET_TOKEN('PBS',PBS);

3082:
3083: --PBS := TO_NUMBER( FND_PROFILE.VALUE('MRP_PURGE_BATCH_SIZE'));
3084:
3085: FND_MESSAGE.SET_NAME('MSC','MSC_CL_PURGE_BATCH_SIZE');
3086: FND_MESSAGE.SET_TOKEN('PBS',PBS);
3087: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
3088:
3089: IF fnd_global.conc_request_id > 0 THEN
3090: v_cp_enabled:= MSC_UTIL.SYS_YES;

Line 3087: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

3083: --PBS := TO_NUMBER( FND_PROFILE.VALUE('MRP_PURGE_BATCH_SIZE'));
3084:
3085: FND_MESSAGE.SET_NAME('MSC','MSC_CL_PURGE_BATCH_SIZE');
3086: FND_MESSAGE.SET_TOKEN('PBS',PBS);
3087: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
3088:
3089: IF fnd_global.conc_request_id > 0 THEN
3090: v_cp_enabled:= MSC_UTIL.SYS_YES;
3091: ELSE

Line 3135: FND_MESSAGE.SET_NAME('MSC','MSC_CL_WORKER_RCV_RET_CODE');

3131: -- ============= Get the Task from Task Que ==============
3132:
3133: lv_pipe_ret_code := DBMS_PIPE.RECEIVE_MESSAGE( v_pipe_task_que, PIPE_TIME_OUT);
3134:
3135: FND_MESSAGE.SET_NAME('MSC','MSC_CL_WORKER_RCV_RET_CODE');
3136: FND_MESSAGE.SET_TOKEN('LV_TASK_NUMBER',lv_pipe_ret_code);
3137: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, FND_MESSAGE.GET);
3138:
3139:

Line 3136: FND_MESSAGE.SET_TOKEN('LV_TASK_NUMBER',lv_pipe_ret_code);

3132:
3133: lv_pipe_ret_code := DBMS_PIPE.RECEIVE_MESSAGE( v_pipe_task_que, PIPE_TIME_OUT);
3134:
3135: FND_MESSAGE.SET_NAME('MSC','MSC_CL_WORKER_RCV_RET_CODE');
3136: FND_MESSAGE.SET_TOKEN('LV_TASK_NUMBER',lv_pipe_ret_code);
3137: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, FND_MESSAGE.GET);
3138:
3139:
3140: IF lv_pipe_ret_code<>0 THEN

Line 3137: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, FND_MESSAGE.GET);

3133: lv_pipe_ret_code := DBMS_PIPE.RECEIVE_MESSAGE( v_pipe_task_que, PIPE_TIME_OUT);
3134:
3135: FND_MESSAGE.SET_NAME('MSC','MSC_CL_WORKER_RCV_RET_CODE');
3136: FND_MESSAGE.SET_TOKEN('LV_TASK_NUMBER',lv_pipe_ret_code);
3137: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, FND_MESSAGE.GET);
3138:
3139:
3140: IF lv_pipe_ret_code<>0 THEN
3141:

Line 3155: FND_MESSAGE.SET_NAME('MSC','MSC_CL_WORKER_TSK_UNPACK');

3151: ELSE
3152: lv_is_waiting := true;
3153: DBMS_PIPE.UNPACK_MESSAGE( lv_task_number);
3154:
3155: FND_MESSAGE.SET_NAME('MSC','MSC_CL_WORKER_TSK_UNPACK');
3156: FND_MESSAGE.SET_TOKEN('LV_TASK_NUM',lv_task_number);
3157: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, FND_MESSAGE.GET);
3158:
3159: EXIT WHEN lv_task_number<= 0; -- No task is left or unknown error occurs.

Line 3156: FND_MESSAGE.SET_TOKEN('LV_TASK_NUM',lv_task_number);

3152: lv_is_waiting := true;
3153: DBMS_PIPE.UNPACK_MESSAGE( lv_task_number);
3154:
3155: FND_MESSAGE.SET_NAME('MSC','MSC_CL_WORKER_TSK_UNPACK');
3156: FND_MESSAGE.SET_TOKEN('LV_TASK_NUM',lv_task_number);
3157: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, FND_MESSAGE.GET);
3158:
3159: EXIT WHEN lv_task_number<= 0; -- No task is left or unknown error occurs.
3160:

Line 3157: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, FND_MESSAGE.GET);

3153: DBMS_PIPE.UNPACK_MESSAGE( lv_task_number);
3154:
3155: FND_MESSAGE.SET_NAME('MSC','MSC_CL_WORKER_TSK_UNPACK');
3156: FND_MESSAGE.SET_TOKEN('LV_TASK_NUM',lv_task_number);
3157: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, FND_MESSAGE.GET);
3158:
3159: EXIT WHEN lv_task_number<= 0; -- No task is left or unknown error occurs.
3160:
3161: -- ============= Execute the Task =============

Line 3191: FND_MESSAGE.SET_NAME('MSC','MSC_CL_EXECUTE_TSK_PROB');

3187:
3188: /** PREPLACE CHANGE END **/
3189:
3190: IF lv_task_status <> OK THEN
3191: FND_MESSAGE.SET_NAME('MSC','MSC_CL_EXECUTE_TSK_PROB');
3192: FND_MESSAGE.SET_TOKEN('LV_TASK_NUMBER',lv_task_number);
3193: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
3194:
3195: DBMS_PIPE.PACK_MESSAGE( -lv_task_number);

Line 3192: FND_MESSAGE.SET_TOKEN('LV_TASK_NUMBER',lv_task_number);

3188: /** PREPLACE CHANGE END **/
3189:
3190: IF lv_task_status <> OK THEN
3191: FND_MESSAGE.SET_NAME('MSC','MSC_CL_EXECUTE_TSK_PROB');
3192: FND_MESSAGE.SET_TOKEN('LV_TASK_NUMBER',lv_task_number);
3193: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
3194:
3195: DBMS_PIPE.PACK_MESSAGE( -lv_task_number);
3196: IF (MSC_UTIL.G_MSC_DEBUG <> 'N' ) THEN

Line 3193: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

3189:
3190: IF lv_task_status <> OK THEN
3191: FND_MESSAGE.SET_NAME('MSC','MSC_CL_EXECUTE_TSK_PROB');
3192: FND_MESSAGE.SET_TOKEN('LV_TASK_NUMBER',lv_task_number);
3193: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
3194:
3195: DBMS_PIPE.PACK_MESSAGE( -lv_task_number);
3196: IF (MSC_UTIL.G_MSC_DEBUG <> 'N' ) THEN
3197: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, 'Sent status '||lv_task_number||' to the monitor.');

Line 3230: FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_SUCCEED');

3226: IF DBMS_PIPE.SEND_MESSAGE( v_pipe_status)<>0 THEN
3227: RAISE EX_PIPE_SND;
3228: END IF;
3229:
3230: FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_SUCCEED');
3231: ERRBUF:= FND_MESSAGE.GET;
3232: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, ERRBUF);
3233:
3234: IF v_warning_flag=MSC_UTIL.SYS_YES THEN

Line 3231: ERRBUF:= FND_MESSAGE.GET;

3227: RAISE EX_PIPE_SND;
3228: END IF;
3229:
3230: FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_SUCCEED');
3231: ERRBUF:= FND_MESSAGE.GET;
3232: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, ERRBUF);
3233:
3234: IF v_warning_flag=MSC_UTIL.SYS_YES THEN
3235: RETCODE:= MSC_UTIL.G_WARNING;

Line 3243: FND_MESSAGE.SET_NAME('MSC','MSC_CL_UNKNOWN_WORKER_ERR');

3239:
3240: ELSE -- unknown error occurs
3241: ROLLBACK;
3242:
3243: FND_MESSAGE.SET_NAME('MSC','MSC_CL_UNKNOWN_WORKER_ERR');
3244: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
3245:
3246: DBMS_PIPE.PACK_MESSAGE( MSC_UTIL.SYS_YES);
3247:

Line 3244: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);

3240: ELSE -- unknown error occurs
3241: ROLLBACK;
3242:
3243: FND_MESSAGE.SET_NAME('MSC','MSC_CL_UNKNOWN_WORKER_ERR');
3244: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
3245:
3246: DBMS_PIPE.PACK_MESSAGE( MSC_UTIL.SYS_YES);
3247:
3248: IF DBMS_PIPE.SEND_MESSAGE( v_pipe_status)<>0 THEN

Line 3252: FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_FAIL');

3248: IF DBMS_PIPE.SEND_MESSAGE( v_pipe_status)<>0 THEN
3249: RAISE EX_PIPE_SND;
3250: END IF;
3251:
3252: FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_FAIL');
3253: ERRBUF:= FND_MESSAGE.GET;
3254: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, ERRBUF);
3255:
3256: RETCODE := MSC_UTIL.G_ERROR;

Line 3253: ERRBUF:= FND_MESSAGE.GET;

3249: RAISE EX_PIPE_SND;
3250: END IF;
3251:
3252: FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_FAIL');
3253: ERRBUF:= FND_MESSAGE.GET;
3254: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, ERRBUF);
3255:
3256: RETCODE := MSC_UTIL.G_ERROR;
3257:

Line 3277: FND_MESSAGE.SET_NAME('MSC', 'MSC_MSG_SEND_FAIL');

3273: DBMS_PIPE.PACK_MESSAGE( UNRESOVLABLE_ERROR);
3274: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, 'Sending message :'||UNRESOVLABLE_ERROR||' to monitor.');
3275:
3276: IF DBMS_PIPE.SEND_MESSAGE( v_pipe_wm)<>0 THEN
3277: FND_MESSAGE.SET_NAME('MSC', 'MSC_MSG_SEND_FAIL');
3278: FND_MESSAGE.SET_TOKEN('PIPE', v_pipe_wm);
3279: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
3280: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, 'FAIL TO SEND MESSAGE!');
3281: END IF;

Line 3278: FND_MESSAGE.SET_TOKEN('PIPE', v_pipe_wm);

3274: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, 'Sending message :'||UNRESOVLABLE_ERROR||' to monitor.');
3275:
3276: IF DBMS_PIPE.SEND_MESSAGE( v_pipe_wm)<>0 THEN
3277: FND_MESSAGE.SET_NAME('MSC', 'MSC_MSG_SEND_FAIL');
3278: FND_MESSAGE.SET_TOKEN('PIPE', v_pipe_wm);
3279: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
3280: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, 'FAIL TO SEND MESSAGE!');
3281: END IF;
3282:

Line 3279: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);

3275:
3276: IF DBMS_PIPE.SEND_MESSAGE( v_pipe_wm)<>0 THEN
3277: FND_MESSAGE.SET_NAME('MSC', 'MSC_MSG_SEND_FAIL');
3278: FND_MESSAGE.SET_TOKEN('PIPE', v_pipe_wm);
3279: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
3280: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, 'FAIL TO SEND MESSAGE!');
3281: END IF;
3282:
3283: -- send a message of 'the worker ends its process' to monitor

Line 3671: FND_MESSAGE.SET_NAME('MSC', 'MSC_X_SHOW_CONFIG');

3667:
3668: -- =========== Data Cleansing =================
3669:
3670: /* SCE Debug */
3671: FND_MESSAGE.SET_NAME('MSC', 'MSC_X_SHOW_CONFIG');
3672: FND_MESSAGE.SET_TOKEN('NAME', MSC_UTIL.G_MSC_CONFIGURATION);
3673: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
3674:
3675: FND_MESSAGE.SET_NAME('MSC', 'MSC_X_SHOW_COMPANY');

Line 3672: FND_MESSAGE.SET_TOKEN('NAME', MSC_UTIL.G_MSC_CONFIGURATION);

3668: -- =========== Data Cleansing =================
3669:
3670: /* SCE Debug */
3671: FND_MESSAGE.SET_NAME('MSC', 'MSC_X_SHOW_CONFIG');
3672: FND_MESSAGE.SET_TOKEN('NAME', MSC_UTIL.G_MSC_CONFIGURATION);
3673: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
3674:
3675: FND_MESSAGE.SET_NAME('MSC', 'MSC_X_SHOW_COMPANY');
3676: FND_MESSAGE.SET_TOKEN('NAME', v_my_company_name);

Line 3673: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

3669:
3670: /* SCE Debug */
3671: FND_MESSAGE.SET_NAME('MSC', 'MSC_X_SHOW_CONFIG');
3672: FND_MESSAGE.SET_TOKEN('NAME', MSC_UTIL.G_MSC_CONFIGURATION);
3673: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
3674:
3675: FND_MESSAGE.SET_NAME('MSC', 'MSC_X_SHOW_COMPANY');
3676: FND_MESSAGE.SET_TOKEN('NAME', v_my_company_name);
3677: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

Line 3675: FND_MESSAGE.SET_NAME('MSC', 'MSC_X_SHOW_COMPANY');

3671: FND_MESSAGE.SET_NAME('MSC', 'MSC_X_SHOW_CONFIG');
3672: FND_MESSAGE.SET_TOKEN('NAME', MSC_UTIL.G_MSC_CONFIGURATION);
3673: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
3674:
3675: FND_MESSAGE.SET_NAME('MSC', 'MSC_X_SHOW_COMPANY');
3676: FND_MESSAGE.SET_TOKEN('NAME', v_my_company_name);
3677: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
3678:
3679: /* Following step does the data cleanup in staging tables and creates

Line 3676: FND_MESSAGE.SET_TOKEN('NAME', v_my_company_name);

3672: FND_MESSAGE.SET_TOKEN('NAME', MSC_UTIL.G_MSC_CONFIGURATION);
3673: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
3674:
3675: FND_MESSAGE.SET_NAME('MSC', 'MSC_X_SHOW_COMPANY');
3676: FND_MESSAGE.SET_TOKEN('NAME', v_my_company_name);
3677: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
3678:
3679: /* Following step does the data cleanup in staging tables and creates
3680: global Ids for Trading Partner and Items.

Line 3677: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

3673: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
3674:
3675: FND_MESSAGE.SET_NAME('MSC', 'MSC_X_SHOW_COMPANY');
3676: FND_MESSAGE.SET_TOKEN('NAME', v_my_company_name);
3677: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
3678:
3679: /* Following step does the data cleanup in staging tables and creates
3680: global Ids for Trading Partner and Items.
3681:

Line 3725: FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_DC_FAIL');

3721: ELSE
3722:
3723: ROLLBACK;
3724:
3725: FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_DC_FAIL');
3726: ERRBUF:= FND_MESSAGE.GET;
3727:
3728: IF SET_ST_STATUS( ERRBUF, RETCODE, pINSTANCE_ID, MSC_UTIL.G_ST_READY) THEN
3729: COMMIT;

Line 3726: ERRBUF:= FND_MESSAGE.GET;

3722:
3723: ROLLBACK;
3724:
3725: FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_DC_FAIL');
3726: ERRBUF:= FND_MESSAGE.GET;
3727:
3728: IF SET_ST_STATUS( ERRBUF, RETCODE, pINSTANCE_ID, MSC_UTIL.G_ST_READY) THEN
3729: COMMIT;
3730: END IF;

Line 3744: FND_MESSAGE.SET_NAME('MSC','MSC_CL_TRANSFORM_KEY_ERR');

3740: IF MSC_CL_SETUP_ODS_LOAD.CLEANSE_DATA AND MSC_CL_SETUP_ODS_LOAD.TRANSFORM_KEYS THEN
3741: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, 'after MSC_CL_SETUP_ODS_LOAD.CLEANSE_DATA and MSC_CL_SETUP_ODS_LOAD.TRANSFORM_KEYS ');
3742: COMMIT;
3743: ELSE
3744: FND_MESSAGE.SET_NAME('MSC','MSC_CL_TRANSFORM_KEY_ERR');
3745: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
3746:
3747: ROLLBACK;
3748:

Line 3745: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);

3741: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, 'after MSC_CL_SETUP_ODS_LOAD.CLEANSE_DATA and MSC_CL_SETUP_ODS_LOAD.TRANSFORM_KEYS ');
3742: COMMIT;
3743: ELSE
3744: FND_MESSAGE.SET_NAME('MSC','MSC_CL_TRANSFORM_KEY_ERR');
3745: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
3746:
3747: ROLLBACK;
3748:
3749: FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_DC_FAIL');

Line 3749: FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_DC_FAIL');

3745: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
3746:
3747: ROLLBACK;
3748:
3749: FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_DC_FAIL');
3750: ERRBUF:= FND_MESSAGE.GET;
3751: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, ERRBUF);
3752: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, SQLERRM);
3753:

Line 3750: ERRBUF:= FND_MESSAGE.GET;

3746:
3747: ROLLBACK;
3748:
3749: FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_DC_FAIL');
3750: ERRBUF:= FND_MESSAGE.GET;
3751: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, ERRBUF);
3752: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, SQLERRM);
3753:
3754: IF SET_ST_STATUS( ERRBUF, RETCODE, pINSTANCE_ID, MSC_UTIL.G_ST_READY) THEN

Line 3782: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');

3778:
3779: -- ============ Load Orgnization, Designator, UOM ==============
3780: /* load trading_partner first to provide organization_code information */
3781:
3782: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
3783: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SETUP_ODS_LOAD.LOAD_TRADING_PARTNER');
3784: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
3785: MSC_CL_SETUP_ODS_LOAD.LOAD_TRADING_PARTNER;
3786:

Line 3783: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SETUP_ODS_LOAD.LOAD_TRADING_PARTNER');

3779: -- ============ Load Orgnization, Designator, UOM ==============
3780: /* load trading_partner first to provide organization_code information */
3781:
3782: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
3783: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SETUP_ODS_LOAD.LOAD_TRADING_PARTNER');
3784: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
3785: MSC_CL_SETUP_ODS_LOAD.LOAD_TRADING_PARTNER;
3786:
3787: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, 'after MSC_CL_SETUP_ODS_LOAD.LOAD_TRADING_PARTNER');

Line 3784: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

3780: /* load trading_partner first to provide organization_code information */
3781:
3782: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
3783: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SETUP_ODS_LOAD.LOAD_TRADING_PARTNER');
3784: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
3785: MSC_CL_SETUP_ODS_LOAD.LOAD_TRADING_PARTNER;
3786:
3787: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, 'after MSC_CL_SETUP_ODS_LOAD.LOAD_TRADING_PARTNER');
3788:

Line 3799: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');

3795: */
3796: IF MSC_UTIL.G_MSC_CONFIGURATION = MSC_UTIL.G_CONF_APS_SCE OR
3797: MSC_UTIL.G_MSC_CONFIGURATION = MSC_UTIL.G_CONF_SCE THEN
3798:
3799: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
3800: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SCE_COLLECTION.POPULATE_TP_MAP_TABLE');
3801: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
3802:
3803: MSC_CL_SCE_COLLECTION.POPULATE_TP_MAP_TABLE(v_instance_id);

Line 3800: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SCE_COLLECTION.POPULATE_TP_MAP_TABLE');

3796: IF MSC_UTIL.G_MSC_CONFIGURATION = MSC_UTIL.G_CONF_APS_SCE OR
3797: MSC_UTIL.G_MSC_CONFIGURATION = MSC_UTIL.G_CONF_SCE THEN
3798:
3799: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
3800: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SCE_COLLECTION.POPULATE_TP_MAP_TABLE');
3801: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
3802:
3803: MSC_CL_SCE_COLLECTION.POPULATE_TP_MAP_TABLE(v_instance_id);
3804:

Line 3801: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

3797: MSC_UTIL.G_MSC_CONFIGURATION = MSC_UTIL.G_CONF_SCE THEN
3798:
3799: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
3800: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SCE_COLLECTION.POPULATE_TP_MAP_TABLE');
3801: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
3802:
3803: MSC_CL_SCE_COLLECTION.POPULATE_TP_MAP_TABLE(v_instance_id);
3804:
3805: END IF;

Line 3813: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');

3809:
3810: /* Load parameters in the Main ODS Load so that this information is available to the function
3811: CALC_RESOURCE_AVAILABILITY called within LOAD_CALENDAR_DATE */
3812:
3813: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
3814: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SETUP_ODS_LOAD.LOAD_PARAMETER');
3815: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
3816: MSC_CL_SETUP_ODS_LOAD.LOAD_PARAMETER;
3817:

Line 3814: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SETUP_ODS_LOAD.LOAD_PARAMETER');

3810: /* Load parameters in the Main ODS Load so that this information is available to the function
3811: CALC_RESOURCE_AVAILABILITY called within LOAD_CALENDAR_DATE */
3812:
3813: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
3814: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SETUP_ODS_LOAD.LOAD_PARAMETER');
3815: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
3816: MSC_CL_SETUP_ODS_LOAD.LOAD_PARAMETER;
3817:
3818: COMMIT;

Line 3815: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

3811: CALC_RESOURCE_AVAILABILITY called within LOAD_CALENDAR_DATE */
3812:
3813: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
3814: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SETUP_ODS_LOAD.LOAD_PARAMETER');
3815: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
3816: MSC_CL_SETUP_ODS_LOAD.LOAD_PARAMETER;
3817:
3818: COMMIT;
3819:

Line 3832: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');

3828:
3829: IF MSC_UTIL.G_MSC_CONFIGURATION = MSC_UTIL.G_CONF_APS_SCE OR
3830: MSC_UTIL.G_MSC_CONFIGURATION = MSC_UTIL.G_CONF_SCE THEN
3831:
3832: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
3833: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SCE_COLLECTION.CLEANSE_TP_ITEMS');
3834: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
3835: MSC_CL_SCE_COLLECTION.CLEANSE_TP_ITEMS(v_instance_id);
3836:

Line 3833: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SCE_COLLECTION.CLEANSE_TP_ITEMS');

3829: IF MSC_UTIL.G_MSC_CONFIGURATION = MSC_UTIL.G_CONF_APS_SCE OR
3830: MSC_UTIL.G_MSC_CONFIGURATION = MSC_UTIL.G_CONF_SCE THEN
3831:
3832: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
3833: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SCE_COLLECTION.CLEANSE_TP_ITEMS');
3834: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
3835: MSC_CL_SCE_COLLECTION.CLEANSE_TP_ITEMS(v_instance_id);
3836:
3837: END IF;

Line 3834: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

3830: MSC_UTIL.G_MSC_CONFIGURATION = MSC_UTIL.G_CONF_SCE THEN
3831:
3832: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
3833: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SCE_COLLECTION.CLEANSE_TP_ITEMS');
3834: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
3835: MSC_CL_SCE_COLLECTION.CLEANSE_TP_ITEMS(v_instance_id);
3836:
3837: END IF;
3838:

Line 3843: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');

3839: /* SCE Change ends */
3840:
3841: /* load schedule to provide schedule designator information */
3842:
3843: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
3844: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LOAD_DESIGNATOR');
3845: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
3846: MSC_CL_DEMAND_ODS_LOAD.LOAD_DESIGNATOR;
3847:

Line 3844: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LOAD_DESIGNATOR');

3840:
3841: /* load schedule to provide schedule designator information */
3842:
3843: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
3844: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LOAD_DESIGNATOR');
3845: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
3846: MSC_CL_DEMAND_ODS_LOAD.LOAD_DESIGNATOR;
3847:
3848: COMMIT;

Line 3845: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

3841: /* load schedule to provide schedule designator information */
3842:
3843: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
3844: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LOAD_DESIGNATOR');
3845: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
3846: MSC_CL_DEMAND_ODS_LOAD.LOAD_DESIGNATOR;
3847:
3848: COMMIT;
3849:

Line 3853: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');

3849:
3850: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'after MSC_CL_DEMAND_ODS_LOAD.LOAD_DESIGNATOR');
3851: /* load forecast designators */
3852:
3853: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
3854: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LOAD_FORECASTS');
3855: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
3856: MSC_CL_DEMAND_ODS_LOAD.LOAD_FORECASTS;
3857:

Line 3854: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LOAD_FORECASTS');

3850: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'after MSC_CL_DEMAND_ODS_LOAD.LOAD_DESIGNATOR');
3851: /* load forecast designators */
3852:
3853: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
3854: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LOAD_FORECASTS');
3855: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
3856: MSC_CL_DEMAND_ODS_LOAD.LOAD_FORECASTS;
3857:
3858: COMMIT;

Line 3855: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

3851: /* load forecast designators */
3852:
3853: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
3854: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LOAD_FORECASTS');
3855: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
3856: MSC_CL_DEMAND_ODS_LOAD.LOAD_FORECASTS;
3857:
3858: COMMIT;
3859:

Line 3862: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');

3858: COMMIT;
3859:
3860: /* load unit of measure */
3861:
3862: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
3863: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SETUP_ODS_LOAD.LOAD_UOM');
3864: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
3865: MSC_CL_SETUP_ODS_LOAD.LOAD_UOM;
3866:

Line 3863: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SETUP_ODS_LOAD.LOAD_UOM');

3859:
3860: /* load unit of measure */
3861:
3862: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
3863: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SETUP_ODS_LOAD.LOAD_UOM');
3864: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
3865: MSC_CL_SETUP_ODS_LOAD.LOAD_UOM;
3866:
3867: COMMIT;

Line 3864: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

3860: /* load unit of measure */
3861:
3862: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
3863: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SETUP_ODS_LOAD.LOAD_UOM');
3864: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
3865: MSC_CL_SETUP_ODS_LOAD.LOAD_UOM;
3866:
3867: COMMIT;
3868:

Line 3874: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');

3870: -- ============================================================
3871: -- We will also load Calendar Dates as Set up entity.
3872: -- We need to do these changes since CP code refers to Calendar
3873: -- ============================================================
3874: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
3875: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SETUP_ODS_LOAD.LOAD_CALENDAR_SET_UP');
3876: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
3877: MSC_CL_SETUP_ODS_LOAD.LOAD_CALENDAR_SET_UP;
3878:

Line 3875: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SETUP_ODS_LOAD.LOAD_CALENDAR_SET_UP');

3871: -- We will also load Calendar Dates as Set up entity.
3872: -- We need to do these changes since CP code refers to Calendar
3873: -- ============================================================
3874: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
3875: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SETUP_ODS_LOAD.LOAD_CALENDAR_SET_UP');
3876: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
3877: MSC_CL_SETUP_ODS_LOAD.LOAD_CALENDAR_SET_UP;
3878:
3879: /* CP-ACK ends */

Line 3876: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

3872: -- We need to do these changes since CP code refers to Calendar
3873: -- ============================================================
3874: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
3875: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SETUP_ODS_LOAD.LOAD_CALENDAR_SET_UP');
3876: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
3877: MSC_CL_SETUP_ODS_LOAD.LOAD_CALENDAR_SET_UP;
3878:
3879: /* CP-ACK ends */
3880:

Line 3942: FND_MESSAGE.SET_NAME('MSC','MSC_CL_SEND_WOR_END');

3938: IF DBMS_PIPE.SEND_MESSAGE( v_pipe_task_que)<>0 THEN
3939: RAISE EX_PIPE_SND;
3940: END IF;
3941:
3942: FND_MESSAGE.SET_NAME('MSC','MSC_CL_SEND_WOR_END');
3943: FND_MESSAGE.SET_TOKEN('LCI',lc_i);
3944: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
3945: END LOOP;
3946:

Line 3943: FND_MESSAGE.SET_TOKEN('LCI',lc_i);

3939: RAISE EX_PIPE_SND;
3940: END IF;
3941:
3942: FND_MESSAGE.SET_NAME('MSC','MSC_CL_SEND_WOR_END');
3943: FND_MESSAGE.SET_TOKEN('LCI',lc_i);
3944: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
3945: END LOOP;
3946:
3947: FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_LAUNCH_WORKER_FAIL');

Line 3944: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

3940: END IF;
3941:
3942: FND_MESSAGE.SET_NAME('MSC','MSC_CL_SEND_WOR_END');
3943: FND_MESSAGE.SET_TOKEN('LCI',lc_i);
3944: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
3945: END LOOP;
3946:
3947: FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_LAUNCH_WORKER_FAIL');
3948: ERRBUF:= FND_MESSAGE.GET;

Line 3947: FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_LAUNCH_WORKER_FAIL');

3943: FND_MESSAGE.SET_TOKEN('LCI',lc_i);
3944: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
3945: END LOOP;
3946:
3947: FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_LAUNCH_WORKER_FAIL');
3948: ERRBUF:= FND_MESSAGE.GET;
3949: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, ERRBUF);
3950: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, SQLERRM);
3951:

Line 3948: ERRBUF:= FND_MESSAGE.GET;

3944: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
3945: END LOOP;
3946:
3947: FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_LAUNCH_WORKER_FAIL');
3948: ERRBUF:= FND_MESSAGE.GET;
3949: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, ERRBUF);
3950: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, SQLERRM);
3951:
3952: RETCODE := MSC_UTIL.G_ERROR;

Line 3958: FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_WORKER_REQUEST_ID');

3954: COMMIT;
3955:
3956: RETURN;
3957: ELSE
3958: FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_WORKER_REQUEST_ID');
3959: FND_MESSAGE.SET_TOKEN('REQUEST_ID', lvs_request_id(lc_i));
3960: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
3961: END IF;
3962:

Line 3959: FND_MESSAGE.SET_TOKEN('REQUEST_ID', lvs_request_id(lc_i));

3955:
3956: RETURN;
3957: ELSE
3958: FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_WORKER_REQUEST_ID');
3959: FND_MESSAGE.SET_TOKEN('REQUEST_ID', lvs_request_id(lc_i));
3960: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
3961: END IF;
3962:
3963: END LOOP;

Line 3960: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

3956: RETURN;
3957: ELSE
3958: FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_WORKER_REQUEST_ID');
3959: FND_MESSAGE.SET_TOKEN('REQUEST_ID', lvs_request_id(lc_i));
3960: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
3961: END IF;
3962:
3963: END LOOP;
3964:

Line 4000: FND_MESSAGE.SET_NAME('MSC','MSC_CL_ERROR_SEND_TSK');

3996: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'Sending DS task number: '||lc_i||' to the queue');
3997:
3998: IF DBMS_PIPE.SEND_MESSAGE( v_pipe_task_que) <> 0 THEN
3999:
4000: FND_MESSAGE.SET_NAME('MSC','MSC_CL_ERROR_SEND_TSK');
4001: FND_MESSAGE.SET_TOKEN('LCI',lc_i);
4002: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
4003:
4004: RAISE EX_PIPE_SND;

Line 4001: FND_MESSAGE.SET_TOKEN('LCI',lc_i);

3997:
3998: IF DBMS_PIPE.SEND_MESSAGE( v_pipe_task_que) <> 0 THEN
3999:
4000: FND_MESSAGE.SET_NAME('MSC','MSC_CL_ERROR_SEND_TSK');
4001: FND_MESSAGE.SET_TOKEN('LCI',lc_i);
4002: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
4003:
4004: RAISE EX_PIPE_SND;
4005: END IF;

Line 4002: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);

3998: IF DBMS_PIPE.SEND_MESSAGE( v_pipe_task_que) <> 0 THEN
3999:
4000: FND_MESSAGE.SET_NAME('MSC','MSC_CL_ERROR_SEND_TSK');
4001: FND_MESSAGE.SET_TOKEN('LCI',lc_i);
4002: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
4003:
4004: RAISE EX_PIPE_SND;
4005: END IF;
4006: ELSE

Line 4021: FND_MESSAGE.SET_NAME('MSC','MSC_CL_ERROR_SEND_TSK');

4017:
4018:
4019: IF DBMS_PIPE.SEND_MESSAGE( v_pipe_task_que)<>0 THEN
4020:
4021: FND_MESSAGE.SET_NAME('MSC','MSC_CL_ERROR_SEND_TSK');
4022: FND_MESSAGE.SET_TOKEN('LCI',lc_i);
4023: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
4024:
4025: RAISE EX_PIPE_SND;

Line 4022: FND_MESSAGE.SET_TOKEN('LCI',lc_i);

4018:
4019: IF DBMS_PIPE.SEND_MESSAGE( v_pipe_task_que)<>0 THEN
4020:
4021: FND_MESSAGE.SET_NAME('MSC','MSC_CL_ERROR_SEND_TSK');
4022: FND_MESSAGE.SET_TOKEN('LCI',lc_i);
4023: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
4024:
4025: RAISE EX_PIPE_SND;
4026: END IF;

Line 4023: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);

4019: IF DBMS_PIPE.SEND_MESSAGE( v_pipe_task_que)<>0 THEN
4020:
4021: FND_MESSAGE.SET_NAME('MSC','MSC_CL_ERROR_SEND_TSK');
4022: FND_MESSAGE.SET_TOKEN('LCI',lc_i);
4023: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
4024:
4025: RAISE EX_PIPE_SND;
4026: END IF;
4027: END IF; /* v_DSMode */

Line 4034: FND_MESSAGE.SET_NAME('MSC','MSC_CL_TOTAL_TSK_ADDED');

4030: DBMS_LOCK.SLEEP( 5); -- initial estimated sleep time
4031:
4032: --lv_task_not_completed := lv_total_task_number;
4033:
4034: FND_MESSAGE.SET_NAME('MSC','MSC_CL_TOTAL_TSK_ADDED');
4035: FND_MESSAGE.SET_TOKEN('LV_TASK_NOT_COMPLETED',lv_task_not_completed);
4036: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, FND_MESSAGE.GET);
4037:
4038: LOOP

Line 4035: FND_MESSAGE.SET_TOKEN('LV_TASK_NOT_COMPLETED',lv_task_not_completed);

4031:
4032: --lv_task_not_completed := lv_total_task_number;
4033:
4034: FND_MESSAGE.SET_NAME('MSC','MSC_CL_TOTAL_TSK_ADDED');
4035: FND_MESSAGE.SET_TOKEN('LV_TASK_NOT_COMPLETED',lv_task_not_completed);
4036: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, FND_MESSAGE.GET);
4037:
4038: LOOP
4039:

Line 4036: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, FND_MESSAGE.GET);

4032: --lv_task_not_completed := lv_total_task_number;
4033:
4034: FND_MESSAGE.SET_NAME('MSC','MSC_CL_TOTAL_TSK_ADDED');
4035: FND_MESSAGE.SET_TOKEN('LV_TASK_NOT_COMPLETED',lv_task_not_completed);
4036: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, FND_MESSAGE.GET);
4037:
4038: LOOP
4039:
4040: var_debug := 1;

Line 4102: FND_MESSAGE.SET_NAME('MSC','MSC_CL_RCV_PIPE_ERR');

4098: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, 'Task number: '||lv_task_number||' re-sent to the pipe queue');
4099: END IF;
4100:
4101: ELSIF lv_pipe_ret_code<> 1 THEN
4102: FND_MESSAGE.SET_NAME('MSC','MSC_CL_RCV_PIPE_ERR');
4103: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
4104:
4105: RAISE EX_PIPE_RCV; -- If the error is not time-out error
4106: END IF;

Line 4103: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);

4099: END IF;
4100:
4101: ELSIF lv_pipe_ret_code<> 1 THEN
4102: FND_MESSAGE.SET_NAME('MSC','MSC_CL_RCV_PIPE_ERR');
4103: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
4104:
4105: RAISE EX_PIPE_RCV; -- If the error is not time-out error
4106: END IF;
4107:

Line 4118: FND_MESSAGE.SET_NAME('MSC','MSC_CL_TSK_NOT_COMP');

4114:
4115: END LOOP;
4116:
4117: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, '----------------------------------------------------');
4118: FND_MESSAGE.SET_NAME('MSC','MSC_CL_TSK_NOT_COMP');
4119: FND_MESSAGE.SET_TOKEN('LV_TASK_NOT_COMPLETED',lv_task_not_completed);
4120: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, FND_MESSAGE.GET);
4121:
4122: IF (var_debug = 1) THEN

Line 4119: FND_MESSAGE.SET_TOKEN('LV_TASK_NOT_COMPLETED',lv_task_not_completed);

4115: END LOOP;
4116:
4117: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, '----------------------------------------------------');
4118: FND_MESSAGE.SET_NAME('MSC','MSC_CL_TSK_NOT_COMP');
4119: FND_MESSAGE.SET_TOKEN('LV_TASK_NOT_COMPLETED',lv_task_not_completed);
4120: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, FND_MESSAGE.GET);
4121:
4122: IF (var_debug = 1) THEN
4123: FND_MESSAGE.SET_NAME('MSC','MSC_CL_ERR_PDC_1');

Line 4120: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, FND_MESSAGE.GET);

4116:
4117: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, '----------------------------------------------------');
4118: FND_MESSAGE.SET_NAME('MSC','MSC_CL_TSK_NOT_COMP');
4119: FND_MESSAGE.SET_TOKEN('LV_TASK_NOT_COMPLETED',lv_task_not_completed);
4120: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, FND_MESSAGE.GET);
4121:
4122: IF (var_debug = 1) THEN
4123: FND_MESSAGE.SET_NAME('MSC','MSC_CL_ERR_PDC_1');
4124: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);

Line 4123: FND_MESSAGE.SET_NAME('MSC','MSC_CL_ERR_PDC_1');

4119: FND_MESSAGE.SET_TOKEN('LV_TASK_NOT_COMPLETED',lv_task_not_completed);
4120: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, FND_MESSAGE.GET);
4121:
4122: IF (var_debug = 1) THEN
4123: FND_MESSAGE.SET_NAME('MSC','MSC_CL_ERR_PDC_1');
4124: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
4125: ELSIF (var_debug = 2) THEN
4126: FND_MESSAGE.SET_NAME('MSC','MSC_CL_ERR_PDC_2');
4127: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);

Line 4124: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);

4120: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, FND_MESSAGE.GET);
4121:
4122: IF (var_debug = 1) THEN
4123: FND_MESSAGE.SET_NAME('MSC','MSC_CL_ERR_PDC_1');
4124: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
4125: ELSIF (var_debug = 2) THEN
4126: FND_MESSAGE.SET_NAME('MSC','MSC_CL_ERR_PDC_2');
4127: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
4128: ELSIF (var_debug = 3) THEN

Line 4126: FND_MESSAGE.SET_NAME('MSC','MSC_CL_ERR_PDC_2');

4122: IF (var_debug = 1) THEN
4123: FND_MESSAGE.SET_NAME('MSC','MSC_CL_ERR_PDC_1');
4124: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
4125: ELSIF (var_debug = 2) THEN
4126: FND_MESSAGE.SET_NAME('MSC','MSC_CL_ERR_PDC_2');
4127: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
4128: ELSIF (var_debug = 3) THEN
4129: FND_MESSAGE.SET_NAME('MSC','MSC_CL_ERR_PDC_3');
4130: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);

Line 4127: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);

4123: FND_MESSAGE.SET_NAME('MSC','MSC_CL_ERR_PDC_1');
4124: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
4125: ELSIF (var_debug = 2) THEN
4126: FND_MESSAGE.SET_NAME('MSC','MSC_CL_ERR_PDC_2');
4127: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
4128: ELSIF (var_debug = 3) THEN
4129: FND_MESSAGE.SET_NAME('MSC','MSC_CL_ERR_PDC_3');
4130: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
4131: ELSIF (var_debug = 4) THEN

Line 4129: FND_MESSAGE.SET_NAME('MSC','MSC_CL_ERR_PDC_3');

4125: ELSIF (var_debug = 2) THEN
4126: FND_MESSAGE.SET_NAME('MSC','MSC_CL_ERR_PDC_2');
4127: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
4128: ELSIF (var_debug = 3) THEN
4129: FND_MESSAGE.SET_NAME('MSC','MSC_CL_ERR_PDC_3');
4130: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
4131: ELSIF (var_debug = 4) THEN
4132: FND_MESSAGE.SET_NAME('MSC','MSC_CL_ERR_PDC_4');
4133: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);

Line 4130: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);

4126: FND_MESSAGE.SET_NAME('MSC','MSC_CL_ERR_PDC_2');
4127: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
4128: ELSIF (var_debug = 3) THEN
4129: FND_MESSAGE.SET_NAME('MSC','MSC_CL_ERR_PDC_3');
4130: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
4131: ELSIF (var_debug = 4) THEN
4132: FND_MESSAGE.SET_NAME('MSC','MSC_CL_ERR_PDC_4');
4133: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
4134: END IF;

Line 4132: FND_MESSAGE.SET_NAME('MSC','MSC_CL_ERR_PDC_4');

4128: ELSIF (var_debug = 3) THEN
4129: FND_MESSAGE.SET_NAME('MSC','MSC_CL_ERR_PDC_3');
4130: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
4131: ELSIF (var_debug = 4) THEN
4132: FND_MESSAGE.SET_NAME('MSC','MSC_CL_ERR_PDC_4');
4133: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
4134: END IF;
4135:
4136: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, '----------------------------------------------------');

Line 4133: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);

4129: FND_MESSAGE.SET_NAME('MSC','MSC_CL_ERR_PDC_3');
4130: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
4131: ELSIF (var_debug = 4) THEN
4132: FND_MESSAGE.SET_NAME('MSC','MSC_CL_ERR_PDC_4');
4133: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
4134: END IF;
4135:
4136: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, '----------------------------------------------------');
4137:

Line 4146: FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_FAIL');

4142: lv_task_number:= -1;
4143:
4144: ROLLBACK;
4145:
4146: FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_FAIL');
4147: ERRBUF:= FND_MESSAGE.GET;
4148: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, ERRBUF);
4149: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, SQLERRM);
4150:

Line 4147: ERRBUF:= FND_MESSAGE.GET;

4143:
4144: ROLLBACK;
4145:
4146: FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_FAIL');
4147: ERRBUF:= FND_MESSAGE.GET;
4148: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, ERRBUF);
4149: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, SQLERRM);
4150:
4151: RETCODE := MSC_UTIL.G_ERROR;

Line 4177: FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_SUCCEED');

4173: RAISE SUPPLIES_INDEX_FAIL;
4174: END IF;
4175: END IF;
4176:
4177: FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_SUCCEED');
4178: ERRBUF:= FND_MESSAGE.GET;
4179: RETCODE := MSC_UTIL.G_SUCCESS ;
4180:
4181: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, ERRBUF);

Line 4178: ERRBUF:= FND_MESSAGE.GET;

4174: END IF;
4175: END IF;
4176:
4177: FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_SUCCEED');
4178: ERRBUF:= FND_MESSAGE.GET;
4179: RETCODE := MSC_UTIL.G_SUCCESS ;
4180:
4181: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, ERRBUF);
4182:

Line 4197: FND_MESSAGE.SET_NAME('MSC','MSC_CL_SEND_WOR_END');

4193: END IF;
4194:
4195: FOR lc_i IN 1..pTotalWorkerNum LOOP
4196:
4197: FND_MESSAGE.SET_NAME('MSC','MSC_CL_SEND_WOR_END');
4198: FND_MESSAGE.SET_TOKEN('LCI',lc_i);
4199: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
4200:
4201: DBMS_PIPE.PACK_MESSAGE( lv_task_number);

Line 4198: FND_MESSAGE.SET_TOKEN('LCI',lc_i);

4194:
4195: FOR lc_i IN 1..pTotalWorkerNum LOOP
4196:
4197: FND_MESSAGE.SET_NAME('MSC','MSC_CL_SEND_WOR_END');
4198: FND_MESSAGE.SET_TOKEN('LCI',lc_i);
4199: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
4200:
4201: DBMS_PIPE.PACK_MESSAGE( lv_task_number);
4202:

Line 4199: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

4195: FOR lc_i IN 1..pTotalWorkerNum LOOP
4196:
4197: FND_MESSAGE.SET_NAME('MSC','MSC_CL_SEND_WOR_END');
4198: FND_MESSAGE.SET_TOKEN('LCI',lc_i);
4199: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
4200:
4201: DBMS_PIPE.PACK_MESSAGE( lv_task_number);
4202:
4203: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'Sending task number: '||lv_task_number||' to the worker '||lc_i);

Line 4222: FND_MESSAGE.SET_NAME('MSC','MSC_CL_WORKER_COMMIT');

4218: IF lv_pipe_ret_code=0 THEN
4219:
4220: lv_worker_committed:= lv_worker_committed+1;
4221:
4222: FND_MESSAGE.SET_NAME('MSC','MSC_CL_WORKER_COMMIT');
4223: FND_MESSAGE.SET_TOKEN('LV_WORKER_COMMITTED',lv_worker_committed);
4224: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
4225:
4226: EXIT WHEN lv_worker_committed= pTotalWorkerNum;

Line 4223: FND_MESSAGE.SET_TOKEN('LV_WORKER_COMMITTED',lv_worker_committed);

4219:
4220: lv_worker_committed:= lv_worker_committed+1;
4221:
4222: FND_MESSAGE.SET_NAME('MSC','MSC_CL_WORKER_COMMIT');
4223: FND_MESSAGE.SET_TOKEN('LV_WORKER_COMMITTED',lv_worker_committed);
4224: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
4225:
4226: EXIT WHEN lv_worker_committed= pTotalWorkerNum;
4227:

Line 4224: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

4220: lv_worker_committed:= lv_worker_committed+1;
4221:
4222: FND_MESSAGE.SET_NAME('MSC','MSC_CL_WORKER_COMMIT');
4223: FND_MESSAGE.SET_TOKEN('LV_WORKER_COMMITTED',lv_worker_committed);
4224: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
4225:
4226: EXIT WHEN lv_worker_committed= pTotalWorkerNum;
4227:
4228: ELSIF lv_pipe_ret_code<> 1 THEN

Line 4242: FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_FAIL_TO_COMMIT');

4238: END LOOP;
4239:
4240: IF lv_worker_committed<> pTotalWorkerNum THEN
4241:
4242: FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_FAIL_TO_COMMIT');
4243: ERRBUF:= FND_MESSAGE.GET;
4244: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, ERRBUF);
4245: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, SQLERRM);
4246:

Line 4243: ERRBUF:= FND_MESSAGE.GET;

4239:
4240: IF lv_worker_committed<> pTotalWorkerNum THEN
4241:
4242: FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_FAIL_TO_COMMIT');
4243: ERRBUF:= FND_MESSAGE.GET;
4244: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, ERRBUF);
4245: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, SQLERRM);
4246:
4247: FND_MESSAGE.SET_NAME('MSC','MSC_CL_CHECK_PDC_LOG');

Line 4247: FND_MESSAGE.SET_NAME('MSC','MSC_CL_CHECK_PDC_LOG');

4243: ERRBUF:= FND_MESSAGE.GET;
4244: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, ERRBUF);
4245: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, SQLERRM);
4246:
4247: FND_MESSAGE.SET_NAME('MSC','MSC_CL_CHECK_PDC_LOG');
4248: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
4249:
4250: RETCODE := MSC_UTIL.G_ERROR;
4251:

Line 4248: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);

4244: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, ERRBUF);
4245: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, SQLERRM);
4246:
4247: FND_MESSAGE.SET_NAME('MSC','MSC_CL_CHECK_PDC_LOG');
4248: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
4249:
4250: RETCODE := MSC_UTIL.G_ERROR;
4251:
4252: ELSE

Line 4312: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');

4308: IF (v_req_ext_po_so_linking) Then
4309: IF ( v_apps_ver >= MSC_UTIL.G_APPS115 ) THEN
4310: BEGIN
4311: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, ' Calling Linking of Sales Order for 11i source ...');
4312: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
4313: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LINK_SUPP_SO_DEMAND_EXT');
4314: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
4315: -- Calling the Linking of external Sales orders for the fix 2353397 --
4316: MSC_CL_DEMAND_ODS_LOAD.LINK_SUPP_SO_DEMAND_EXT;

Line 4313: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LINK_SUPP_SO_DEMAND_EXT');

4309: IF ( v_apps_ver >= MSC_UTIL.G_APPS115 ) THEN
4310: BEGIN
4311: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, ' Calling Linking of Sales Order for 11i source ...');
4312: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
4313: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LINK_SUPP_SO_DEMAND_EXT');
4314: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
4315: -- Calling the Linking of external Sales orders for the fix 2353397 --
4316: MSC_CL_DEMAND_ODS_LOAD.LINK_SUPP_SO_DEMAND_EXT;
4317: END;

Line 4314: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

4310: BEGIN
4311: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, ' Calling Linking of Sales Order for 11i source ...');
4312: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
4313: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LINK_SUPP_SO_DEMAND_EXT');
4314: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
4315: -- Calling the Linking of external Sales orders for the fix 2353397 --
4316: MSC_CL_DEMAND_ODS_LOAD.LINK_SUPP_SO_DEMAND_EXT;
4317: END;
4318:

Line 4413: FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_CALC_RES_AVAIL_FAIL');

4409: lv_ret_res_ava:=MSC_RESOURCE_AVAILABILITY.CALC_RESOURCE_AVAILABILITY(v_resource_start_time,v_coll_prec.org_group_flag,FALSE);
4410:
4411:
4412: IF lv_ret_res_ava = 2 THEN
4413: FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_CALC_RES_AVAIL_FAIL');
4414: ERRBUF:= FND_MESSAGE.GET;
4415: v_warning_flag:=MSC_UTIL.SYS_YES;
4416: ELSIF lv_ret_res_ava <> 0 THEN
4417: FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_CALC_RES_AVAIL_FAIL');

Line 4414: ERRBUF:= FND_MESSAGE.GET;

4410:
4411:
4412: IF lv_ret_res_ava = 2 THEN
4413: FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_CALC_RES_AVAIL_FAIL');
4414: ERRBUF:= FND_MESSAGE.GET;
4415: v_warning_flag:=MSC_UTIL.SYS_YES;
4416: ELSIF lv_ret_res_ava <> 0 THEN
4417: FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_CALC_RES_AVAIL_FAIL');
4418: ERRBUF:= FND_MESSAGE.GET;

Line 4417: FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_CALC_RES_AVAIL_FAIL');

4413: FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_CALC_RES_AVAIL_FAIL');
4414: ERRBUF:= FND_MESSAGE.GET;
4415: v_warning_flag:=MSC_UTIL.SYS_YES;
4416: ELSIF lv_ret_res_ava <> 0 THEN
4417: FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_CALC_RES_AVAIL_FAIL');
4418: ERRBUF:= FND_MESSAGE.GET;
4419: RETCODE:= MSC_UTIL.G_ERROR;
4420:
4421:

Line 4418: ERRBUF:= FND_MESSAGE.GET;

4414: ERRBUF:= FND_MESSAGE.GET;
4415: v_warning_flag:=MSC_UTIL.SYS_YES;
4416: ELSIF lv_ret_res_ava <> 0 THEN
4417: FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_CALC_RES_AVAIL_FAIL');
4418: ERRBUF:= FND_MESSAGE.GET;
4419: RETCODE:= MSC_UTIL.G_ERROR;
4420:
4421:
4422: -- ROLLBACK WORK TO SAVEPOINT WORKERS_COMMITTED;

Line 4646: FND_MESSAGE.SET_NAME('MSC', 'MSC_MSG_SEND_FAIL');

4642: NULL;
4643: END IF;
4644: END IF;
4645:
4646: FND_MESSAGE.SET_NAME('MSC', 'MSC_MSG_SEND_FAIL');
4647: FND_MESSAGE.SET_TOKEN('PIPE', v_pipe_wm);
4648: ERRBUF:= FND_MESSAGE.GET;
4649:
4650: RETCODE := MSC_UTIL.G_ERROR;

Line 4647: FND_MESSAGE.SET_TOKEN('PIPE', v_pipe_wm);

4643: END IF;
4644: END IF;
4645:
4646: FND_MESSAGE.SET_NAME('MSC', 'MSC_MSG_SEND_FAIL');
4647: FND_MESSAGE.SET_TOKEN('PIPE', v_pipe_wm);
4648: ERRBUF:= FND_MESSAGE.GET;
4649:
4650: RETCODE := MSC_UTIL.G_ERROR;
4651: --Rollback swap partitions

Line 4648: ERRBUF:= FND_MESSAGE.GET;

4644: END IF;
4645:
4646: FND_MESSAGE.SET_NAME('MSC', 'MSC_MSG_SEND_FAIL');
4647: FND_MESSAGE.SET_TOKEN('PIPE', v_pipe_wm);
4648: ERRBUF:= FND_MESSAGE.GET;
4649:
4650: RETCODE := MSC_UTIL.G_ERROR;
4651: --Rollback swap partitions
4652: IF NOT MSC_CL_EXCHANGE_PARTTBL.UNDO_STG_ODS_SWAP THEN

Line 4668: FND_MESSAGE.SET_NAME('MSC', 'MSC_TIMEOUT');

4664: NULL;
4665: END IF;
4666: END IF;
4667:
4668: FND_MESSAGE.SET_NAME('MSC', 'MSC_TIMEOUT');
4669: ERRBUF:= FND_MESSAGE.GET;
4670: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, SQLERRM);
4671:
4672: RETCODE := MSC_UTIL.G_ERROR;

Line 4669: ERRBUF:= FND_MESSAGE.GET;

4665: END IF;
4666: END IF;
4667:
4668: FND_MESSAGE.SET_NAME('MSC', 'MSC_TIMEOUT');
4669: ERRBUF:= FND_MESSAGE.GET;
4670: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, SQLERRM);
4671:
4672: RETCODE := MSC_UTIL.G_ERROR;
4673:

Line 4722: FND_MESSAGE.SET_NAME('MSC', 'MSC_MSG_SEND_FAIL');

4718:
4719: DBMS_PIPE.PACK_MESSAGE( UNRESOVLABLE_ERROR);
4720:
4721: IF DBMS_PIPE.SEND_MESSAGE( v_pipe_wm)<>0 THEN
4722: FND_MESSAGE.SET_NAME('MSC', 'MSC_MSG_SEND_FAIL');
4723: FND_MESSAGE.SET_TOKEN('PIPE', v_pipe_wm);
4724: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
4725: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, 'DELETER:FAIL TO SEND MESSAGE!');
4726: -- should raise EXCEPTION

Line 4723: FND_MESSAGE.SET_TOKEN('PIPE', v_pipe_wm);

4719: DBMS_PIPE.PACK_MESSAGE( UNRESOVLABLE_ERROR);
4720:
4721: IF DBMS_PIPE.SEND_MESSAGE( v_pipe_wm)<>0 THEN
4722: FND_MESSAGE.SET_NAME('MSC', 'MSC_MSG_SEND_FAIL');
4723: FND_MESSAGE.SET_TOKEN('PIPE', v_pipe_wm);
4724: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
4725: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, 'DELETER:FAIL TO SEND MESSAGE!');
4726: -- should raise EXCEPTION
4727: END IF;

Line 4724: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);

4720:
4721: IF DBMS_PIPE.SEND_MESSAGE( v_pipe_wm)<>0 THEN
4722: FND_MESSAGE.SET_NAME('MSC', 'MSC_MSG_SEND_FAIL');
4723: FND_MESSAGE.SET_TOKEN('PIPE', v_pipe_wm);
4724: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
4725: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, 'DELETER:FAIL TO SEND MESSAGE!');
4726: -- should raise EXCEPTION
4727: END IF;
4728:

Line 5264: FND_MESSAGE.SET_NAME('MSC', 'MSC_X_SHOW_CONFIG');

5260:
5261: -- =========== Data Cleansing =================
5262:
5263: /* SCE Debug */
5264: FND_MESSAGE.SET_NAME('MSC', 'MSC_X_SHOW_CONFIG');
5265: FND_MESSAGE.SET_TOKEN('NAME', MSC_UTIL.G_MSC_CONFIGURATION);
5266: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
5267:
5268: FND_MESSAGE.SET_NAME('MSC', 'MSC_X_SHOW_COMPANY');

Line 5265: FND_MESSAGE.SET_TOKEN('NAME', MSC_UTIL.G_MSC_CONFIGURATION);

5261: -- =========== Data Cleansing =================
5262:
5263: /* SCE Debug */
5264: FND_MESSAGE.SET_NAME('MSC', 'MSC_X_SHOW_CONFIG');
5265: FND_MESSAGE.SET_TOKEN('NAME', MSC_UTIL.G_MSC_CONFIGURATION);
5266: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
5267:
5268: FND_MESSAGE.SET_NAME('MSC', 'MSC_X_SHOW_COMPANY');
5269: FND_MESSAGE.SET_TOKEN('NAME', v_my_company_name);

Line 5266: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

5262:
5263: /* SCE Debug */
5264: FND_MESSAGE.SET_NAME('MSC', 'MSC_X_SHOW_CONFIG');
5265: FND_MESSAGE.SET_TOKEN('NAME', MSC_UTIL.G_MSC_CONFIGURATION);
5266: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
5267:
5268: FND_MESSAGE.SET_NAME('MSC', 'MSC_X_SHOW_COMPANY');
5269: FND_MESSAGE.SET_TOKEN('NAME', v_my_company_name);
5270: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

Line 5268: FND_MESSAGE.SET_NAME('MSC', 'MSC_X_SHOW_COMPANY');

5264: FND_MESSAGE.SET_NAME('MSC', 'MSC_X_SHOW_CONFIG');
5265: FND_MESSAGE.SET_TOKEN('NAME', MSC_UTIL.G_MSC_CONFIGURATION);
5266: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
5267:
5268: FND_MESSAGE.SET_NAME('MSC', 'MSC_X_SHOW_COMPANY');
5269: FND_MESSAGE.SET_TOKEN('NAME', v_my_company_name);
5270: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
5271:
5272: /* Following step does the data cleanup in staging tables and creates

Line 5269: FND_MESSAGE.SET_TOKEN('NAME', v_my_company_name);

5265: FND_MESSAGE.SET_TOKEN('NAME', MSC_UTIL.G_MSC_CONFIGURATION);
5266: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
5267:
5268: FND_MESSAGE.SET_NAME('MSC', 'MSC_X_SHOW_COMPANY');
5269: FND_MESSAGE.SET_TOKEN('NAME', v_my_company_name);
5270: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
5271:
5272: /* Following step does the data cleanup in staging tables and creates
5273: global Ids for Trading Partner and Items.

Line 5270: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

5266: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
5267:
5268: FND_MESSAGE.SET_NAME('MSC', 'MSC_X_SHOW_COMPANY');
5269: FND_MESSAGE.SET_TOKEN('NAME', v_my_company_name);
5270: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
5271:
5272: /* Following step does the data cleanup in staging tables and creates
5273: global Ids for Trading Partner and Items.
5274:

Line 5293: FND_MESSAGE.SET_NAME('MSC','MSC_CL_TRANSFORM_KEY_ERR');

5289:
5290: COMMIT;
5291:
5292: ELSE
5293: FND_MESSAGE.SET_NAME('MSC','MSC_CL_TRANSFORM_KEY_ERR');
5294: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
5295: ROLLBACK;
5296:
5297: FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_DC_FAIL');

Line 5294: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);

5290: COMMIT;
5291:
5292: ELSE
5293: FND_MESSAGE.SET_NAME('MSC','MSC_CL_TRANSFORM_KEY_ERR');
5294: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
5295: ROLLBACK;
5296:
5297: FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_DC_FAIL');
5298: ERRBUF:= FND_MESSAGE.GET;

Line 5297: FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_DC_FAIL');

5293: FND_MESSAGE.SET_NAME('MSC','MSC_CL_TRANSFORM_KEY_ERR');
5294: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
5295: ROLLBACK;
5296:
5297: FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_DC_FAIL');
5298: ERRBUF:= FND_MESSAGE.GET;
5299: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, ERRBUF);
5300: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, SQLERRM);
5301:

Line 5298: ERRBUF:= FND_MESSAGE.GET;

5294: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
5295: ROLLBACK;
5296:
5297: FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_DC_FAIL');
5298: ERRBUF:= FND_MESSAGE.GET;
5299: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, ERRBUF);
5300: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, SQLERRM);
5301:
5302: IF SET_ST_STATUS( ERRBUF, RETCODE, pINSTANCE_ID, MSC_UTIL.G_ST_READY) THEN

Line 5345: FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_DC_FAIL');

5341: ELSE
5342:
5343: ROLLBACK;
5344:
5345: FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_DC_FAIL');
5346: ERRBUF:= FND_MESSAGE.GET;
5347:
5348: IF SET_ST_STATUS( ERRBUF, RETCODE, pINSTANCE_ID, MSC_UTIL.G_ST_READY) THEN
5349: COMMIT;

Line 5346: ERRBUF:= FND_MESSAGE.GET;

5342:
5343: ROLLBACK;
5344:
5345: FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_DC_FAIL');
5346: ERRBUF:= FND_MESSAGE.GET;
5347:
5348: IF SET_ST_STATUS( ERRBUF, RETCODE, pINSTANCE_ID, MSC_UTIL.G_ST_READY) THEN
5349: COMMIT;
5350: END IF;

Line 5371: FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_DC_FAIL');

5367: ELSE
5368:
5369: ROLLBACK;
5370:
5371: FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_DC_FAIL');
5372: ERRBUF:= FND_MESSAGE.GET;
5373:
5374: IF SET_ST_STATUS( ERRBUF, RETCODE, pINSTANCE_ID, MSC_UTIL.G_ST_READY) THEN
5375: COMMIT;

Line 5372: ERRBUF:= FND_MESSAGE.GET;

5368:
5369: ROLLBACK;
5370:
5371: FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_DC_FAIL');
5372: ERRBUF:= FND_MESSAGE.GET;
5373:
5374: IF SET_ST_STATUS( ERRBUF, RETCODE, pINSTANCE_ID, MSC_UTIL.G_ST_READY) THEN
5375: COMMIT;
5376: END IF;

Line 5411: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');

5407: WHERE mai.INSTANCE_ID= v_instance_id;
5408: commit;
5409: end if;
5410:
5411: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
5412: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SETUP_ODS_LOAD.LOAD_TRADING_PARTNER');
5413: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
5414: MSC_CL_SETUP_ODS_LOAD.LOAD_TRADING_PARTNER;
5415:

Line 5412: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SETUP_ODS_LOAD.LOAD_TRADING_PARTNER');

5408: commit;
5409: end if;
5410:
5411: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
5412: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SETUP_ODS_LOAD.LOAD_TRADING_PARTNER');
5413: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
5414: MSC_CL_SETUP_ODS_LOAD.LOAD_TRADING_PARTNER;
5415:
5416: /* SCE Change starts */

Line 5413: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

5409: end if;
5410:
5411: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
5412: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SETUP_ODS_LOAD.LOAD_TRADING_PARTNER');
5413: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
5414: MSC_CL_SETUP_ODS_LOAD.LOAD_TRADING_PARTNER;
5415:
5416: /* SCE Change starts */
5417: /* By this time Trading Partners , Organizations are loaded into planning area as well as collaboration area. Now we can populate the

Line 5423: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');

5419: Perform this step if the profile option is 'APS + SCE' OR 'SCE'.
5420: */
5421: IF MSC_UTIL.G_MSC_CONFIGURATION = MSC_UTIL.G_CONF_APS_SCE OR
5422: MSC_UTIL.G_MSC_CONFIGURATION = MSC_UTIL.G_CONF_SCE THEN
5423: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
5424: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SCE_COLLECTION.POPULATE_TP_MAP_TABLE');
5425: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
5426: MSC_CL_SCE_COLLECTION.POPULATE_TP_MAP_TABLE(v_instance_id);
5427: END IF;

Line 5424: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SCE_COLLECTION.POPULATE_TP_MAP_TABLE');

5420: */
5421: IF MSC_UTIL.G_MSC_CONFIGURATION = MSC_UTIL.G_CONF_APS_SCE OR
5422: MSC_UTIL.G_MSC_CONFIGURATION = MSC_UTIL.G_CONF_SCE THEN
5423: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
5424: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SCE_COLLECTION.POPULATE_TP_MAP_TABLE');
5425: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
5426: MSC_CL_SCE_COLLECTION.POPULATE_TP_MAP_TABLE(v_instance_id);
5427: END IF;
5428: -- END IF;

Line 5425: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

5421: IF MSC_UTIL.G_MSC_CONFIGURATION = MSC_UTIL.G_CONF_APS_SCE OR
5422: MSC_UTIL.G_MSC_CONFIGURATION = MSC_UTIL.G_CONF_SCE THEN
5423: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
5424: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SCE_COLLECTION.POPULATE_TP_MAP_TABLE');
5425: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
5426: MSC_CL_SCE_COLLECTION.POPULATE_TP_MAP_TABLE(v_instance_id);
5427: END IF;
5428: -- END IF;
5429:

Line 5451: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');

5447: CALC_RESOURCE_AVAILABILITY called within LOAD_CALENDAR_DATE */
5448:
5449: IF v_coll_prec.parameter_flag = MSC_UTIL.SYS_YES THEN
5450:
5451: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
5452: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SETUP_ODS_LOAD.LOAD_PARAMETER');
5453: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
5454: MSC_CL_SETUP_ODS_LOAD.LOAD_PARAMETER;
5455: END IF;

Line 5452: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SETUP_ODS_LOAD.LOAD_PARAMETER');

5448:
5449: IF v_coll_prec.parameter_flag = MSC_UTIL.SYS_YES THEN
5450:
5451: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
5452: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SETUP_ODS_LOAD.LOAD_PARAMETER');
5453: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
5454: MSC_CL_SETUP_ODS_LOAD.LOAD_PARAMETER;
5455: END IF;
5456:

Line 5453: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

5449: IF v_coll_prec.parameter_flag = MSC_UTIL.SYS_YES THEN
5450:
5451: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
5452: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SETUP_ODS_LOAD.LOAD_PARAMETER');
5453: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
5454: MSC_CL_SETUP_ODS_LOAD.LOAD_PARAMETER;
5455: END IF;
5456:
5457: COMMIT;

Line 5476: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');

5472: v_is_incremental_refresh := TRUE;
5473: v_is_partial_refresh := FALSE;
5474: end if;
5475:
5476: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
5477: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LOAD_DESIGNATOR');
5478: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
5479: MSC_CL_DEMAND_ODS_LOAD.LOAD_DESIGNATOR;
5480:

Line 5477: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LOAD_DESIGNATOR');

5473: v_is_partial_refresh := FALSE;
5474: end if;
5475:
5476: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
5477: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LOAD_DESIGNATOR');
5478: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
5479: MSC_CL_DEMAND_ODS_LOAD.LOAD_DESIGNATOR;
5480:
5481: COMMIT;

Line 5478: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

5474: end if;
5475:
5476: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
5477: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LOAD_DESIGNATOR');
5478: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
5479: MSC_CL_DEMAND_ODS_LOAD.LOAD_DESIGNATOR;
5480:
5481: COMMIT;
5482:

Line 5494: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');

5490: v_is_incremental_refresh := TRUE;
5491: v_is_partial_refresh := FALSE;
5492: end if;
5493:
5494: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
5495: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LOAD_FORECASTS');
5496: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
5497: MSC_CL_DEMAND_ODS_LOAD.LOAD_FORECASTS;
5498:

Line 5495: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LOAD_FORECASTS');

5491: v_is_partial_refresh := FALSE;
5492: end if;
5493:
5494: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
5495: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LOAD_FORECASTS');
5496: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
5497: MSC_CL_DEMAND_ODS_LOAD.LOAD_FORECASTS;
5498:
5499: END IF;

Line 5496: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

5492: end if;
5493:
5494: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
5495: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LOAD_FORECASTS');
5496: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
5497: MSC_CL_DEMAND_ODS_LOAD.LOAD_FORECASTS;
5498:
5499: END IF;
5500:

Line 5511: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');

5507: v_is_incremental_refresh := TRUE;
5508: v_is_partial_refresh := FALSE;
5509: end if;
5510:
5511: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
5512: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SETUP_ODS_LOAD.LOAD_UOM');
5513: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
5514: MSC_CL_SETUP_ODS_LOAD.LOAD_UOM;
5515:

Line 5512: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SETUP_ODS_LOAD.LOAD_UOM');

5508: v_is_partial_refresh := FALSE;
5509: end if;
5510:
5511: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
5512: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SETUP_ODS_LOAD.LOAD_UOM');
5513: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
5514: MSC_CL_SETUP_ODS_LOAD.LOAD_UOM;
5515:
5516: COMMIT;

Line 5513: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

5509: end if;
5510:
5511: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
5512: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SETUP_ODS_LOAD.LOAD_UOM');
5513: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
5514: MSC_CL_SETUP_ODS_LOAD.LOAD_UOM;
5515:
5516: COMMIT;
5517:

Line 5532: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');

5528: v_is_incremental_refresh := TRUE;
5529: v_is_partial_refresh := FALSE;
5530: end if;
5531:
5532: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
5533: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SETUP_ODS_LOAD.LOAD_CALENDAR_SET_UP');
5534: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
5535: MSC_CL_SETUP_ODS_LOAD.LOAD_CALENDAR_SET_UP;
5536:

Line 5533: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SETUP_ODS_LOAD.LOAD_CALENDAR_SET_UP');

5529: v_is_partial_refresh := FALSE;
5530: end if;
5531:
5532: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
5533: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SETUP_ODS_LOAD.LOAD_CALENDAR_SET_UP');
5534: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
5535: MSC_CL_SETUP_ODS_LOAD.LOAD_CALENDAR_SET_UP;
5536:
5537: END IF;

Line 5534: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

5530: end if;
5531:
5532: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
5533: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SETUP_ODS_LOAD.LOAD_CALENDAR_SET_UP');
5534: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
5535: MSC_CL_SETUP_ODS_LOAD.LOAD_CALENDAR_SET_UP;
5536:
5537: END IF;
5538:

Line 5599: FND_MESSAGE.SET_NAME('MSC','MSC_CL_SEND_WOR_END');

5595: IF DBMS_PIPE.SEND_MESSAGE( v_pipe_task_que)<>0 THEN
5596: RAISE EX_PIPE_SND;
5597: END IF;
5598:
5599: FND_MESSAGE.SET_NAME('MSC','MSC_CL_SEND_WOR_END');
5600: FND_MESSAGE.SET_TOKEN('LCI',lc_i);
5601: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
5602:
5603: END LOOP;

Line 5600: FND_MESSAGE.SET_TOKEN('LCI',lc_i);

5596: RAISE EX_PIPE_SND;
5597: END IF;
5598:
5599: FND_MESSAGE.SET_NAME('MSC','MSC_CL_SEND_WOR_END');
5600: FND_MESSAGE.SET_TOKEN('LCI',lc_i);
5601: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
5602:
5603: END LOOP;
5604:

Line 5601: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

5597: END IF;
5598:
5599: FND_MESSAGE.SET_NAME('MSC','MSC_CL_SEND_WOR_END');
5600: FND_MESSAGE.SET_TOKEN('LCI',lc_i);
5601: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
5602:
5603: END LOOP;
5604:
5605: FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_LAUNCH_WORKER_FAIL');

Line 5605: FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_LAUNCH_WORKER_FAIL');

5601: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
5602:
5603: END LOOP;
5604:
5605: FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_LAUNCH_WORKER_FAIL');
5606: ERRBUF:= FND_MESSAGE.GET;
5607: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, ERRBUF);
5608:
5609: RETCODE := MSC_UTIL.G_ERROR;

Line 5606: ERRBUF:= FND_MESSAGE.GET;

5602:
5603: END LOOP;
5604:
5605: FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_LAUNCH_WORKER_FAIL');
5606: ERRBUF:= FND_MESSAGE.GET;
5607: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, ERRBUF);
5608:
5609: RETCODE := MSC_UTIL.G_ERROR;
5610:

Line 5620: FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_WORKER_REQUEST_ID');

5616: COMMIT;
5617:
5618: RETURN;
5619: ELSE
5620: FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_WORKER_REQUEST_ID');
5621: FND_MESSAGE.SET_TOKEN('REQUEST_ID', lvs_request_id(lc_i));
5622: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
5623: END IF;
5624:

Line 5621: FND_MESSAGE.SET_TOKEN('REQUEST_ID', lvs_request_id(lc_i));

5617:
5618: RETURN;
5619: ELSE
5620: FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_WORKER_REQUEST_ID');
5621: FND_MESSAGE.SET_TOKEN('REQUEST_ID', lvs_request_id(lc_i));
5622: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
5623: END IF;
5624:
5625: END LOOP;

Line 5622: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

5618: RETURN;
5619: ELSE
5620: FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_WORKER_REQUEST_ID');
5621: FND_MESSAGE.SET_TOKEN('REQUEST_ID', lvs_request_id(lc_i));
5622: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
5623: END IF;
5624:
5625: END LOOP;
5626:

Line 5672: FND_MESSAGE.SET_NAME('MSC','MSC_CL_ERROR_SEND_TSK');

5668: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'Sending task number: '||lc_i||' to the queue');
5669:
5670: IF DBMS_PIPE.SEND_MESSAGE( v_pipe_task_que)<>0 THEN
5671:
5672: FND_MESSAGE.SET_NAME('MSC','MSC_CL_ERROR_SEND_TSK');
5673: FND_MESSAGE.SET_TOKEN('LCI',lc_i);
5674: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
5675:
5676: RAISE EX_PIPE_SND;

Line 5673: FND_MESSAGE.SET_TOKEN('LCI',lc_i);

5669:
5670: IF DBMS_PIPE.SEND_MESSAGE( v_pipe_task_que)<>0 THEN
5671:
5672: FND_MESSAGE.SET_NAME('MSC','MSC_CL_ERROR_SEND_TSK');
5673: FND_MESSAGE.SET_TOKEN('LCI',lc_i);
5674: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
5675:
5676: RAISE EX_PIPE_SND;
5677: END IF;

Line 5674: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

5670: IF DBMS_PIPE.SEND_MESSAGE( v_pipe_task_que)<>0 THEN
5671:
5672: FND_MESSAGE.SET_NAME('MSC','MSC_CL_ERROR_SEND_TSK');
5673: FND_MESSAGE.SET_TOKEN('LCI',lc_i);
5674: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
5675:
5676: RAISE EX_PIPE_SND;
5677: END IF;
5678:

Line 5785: FND_MESSAGE.SET_NAME('MSC','MSC_CL_RCV_PIPE_ERR');

5781:
5782: END IF;
5783:
5784: ELSIF lv_pipe_ret_code<> 1 THEN
5785: FND_MESSAGE.SET_NAME('MSC','MSC_CL_RCV_PIPE_ERR');
5786: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
5787:
5788: RAISE EX_PIPE_RCV; -- If the error is not time-out error
5789: END IF;

Line 5786: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);

5782: END IF;
5783:
5784: ELSIF lv_pipe_ret_code<> 1 THEN
5785: FND_MESSAGE.SET_NAME('MSC','MSC_CL_RCV_PIPE_ERR');
5786: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
5787:
5788: RAISE EX_PIPE_RCV; -- If the error is not time-out error
5789: END IF;
5790:

Line 5801: FND_MESSAGE.SET_NAME('MSC','MSC_CL_TSK_NOT_COMP');

5797:
5798: END LOOP;
5799:
5800: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, '----------------------------------------------------');
5801: FND_MESSAGE.SET_NAME('MSC','MSC_CL_TSK_NOT_COMP');
5802: FND_MESSAGE.SET_TOKEN('LV_TASK_NOT_COMPLETED',lv_task_not_completed);
5803: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, FND_MESSAGE.GET);
5804:
5805: IF (var_debug = 1) THEN

Line 5802: FND_MESSAGE.SET_TOKEN('LV_TASK_NOT_COMPLETED',lv_task_not_completed);

5798: END LOOP;
5799:
5800: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, '----------------------------------------------------');
5801: FND_MESSAGE.SET_NAME('MSC','MSC_CL_TSK_NOT_COMP');
5802: FND_MESSAGE.SET_TOKEN('LV_TASK_NOT_COMPLETED',lv_task_not_completed);
5803: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, FND_MESSAGE.GET);
5804:
5805: IF (var_debug = 1) THEN
5806: FND_MESSAGE.SET_NAME('MSC','MSC_CL_ERR_PDC_3');

Line 5803: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, FND_MESSAGE.GET);

5799:
5800: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, '----------------------------------------------------');
5801: FND_MESSAGE.SET_NAME('MSC','MSC_CL_TSK_NOT_COMP');
5802: FND_MESSAGE.SET_TOKEN('LV_TASK_NOT_COMPLETED',lv_task_not_completed);
5803: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, FND_MESSAGE.GET);
5804:
5805: IF (var_debug = 1) THEN
5806: FND_MESSAGE.SET_NAME('MSC','MSC_CL_ERR_PDC_3');
5807: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);

Line 5806: FND_MESSAGE.SET_NAME('MSC','MSC_CL_ERR_PDC_3');

5802: FND_MESSAGE.SET_TOKEN('LV_TASK_NOT_COMPLETED',lv_task_not_completed);
5803: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, FND_MESSAGE.GET);
5804:
5805: IF (var_debug = 1) THEN
5806: FND_MESSAGE.SET_NAME('MSC','MSC_CL_ERR_PDC_3');
5807: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
5808: ELSIF (var_debug = 2) THEN
5809: FND_MESSAGE.SET_NAME('MSC','MSC_CL_ERR_PDC_1');
5810: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);

Line 5807: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);

5803: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, FND_MESSAGE.GET);
5804:
5805: IF (var_debug = 1) THEN
5806: FND_MESSAGE.SET_NAME('MSC','MSC_CL_ERR_PDC_3');
5807: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
5808: ELSIF (var_debug = 2) THEN
5809: FND_MESSAGE.SET_NAME('MSC','MSC_CL_ERR_PDC_1');
5810: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
5811: ELSIF (var_debug = 3) THEN

Line 5809: FND_MESSAGE.SET_NAME('MSC','MSC_CL_ERR_PDC_1');

5805: IF (var_debug = 1) THEN
5806: FND_MESSAGE.SET_NAME('MSC','MSC_CL_ERR_PDC_3');
5807: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
5808: ELSIF (var_debug = 2) THEN
5809: FND_MESSAGE.SET_NAME('MSC','MSC_CL_ERR_PDC_1');
5810: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
5811: ELSIF (var_debug = 3) THEN
5812: FND_MESSAGE.SET_NAME('MSC','MSC_CL_ERR_PDC_2');
5813: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);

Line 5810: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);

5806: FND_MESSAGE.SET_NAME('MSC','MSC_CL_ERR_PDC_3');
5807: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
5808: ELSIF (var_debug = 2) THEN
5809: FND_MESSAGE.SET_NAME('MSC','MSC_CL_ERR_PDC_1');
5810: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
5811: ELSIF (var_debug = 3) THEN
5812: FND_MESSAGE.SET_NAME('MSC','MSC_CL_ERR_PDC_2');
5813: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
5814: ELSIF (var_debug = 4) THEN

Line 5812: FND_MESSAGE.SET_NAME('MSC','MSC_CL_ERR_PDC_2');

5808: ELSIF (var_debug = 2) THEN
5809: FND_MESSAGE.SET_NAME('MSC','MSC_CL_ERR_PDC_1');
5810: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
5811: ELSIF (var_debug = 3) THEN
5812: FND_MESSAGE.SET_NAME('MSC','MSC_CL_ERR_PDC_2');
5813: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
5814: ELSIF (var_debug = 4) THEN
5815: FND_MESSAGE.SET_NAME('MSC','MSC_CL_ERR_PDC_3');
5816: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);

Line 5813: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);

5809: FND_MESSAGE.SET_NAME('MSC','MSC_CL_ERR_PDC_1');
5810: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
5811: ELSIF (var_debug = 3) THEN
5812: FND_MESSAGE.SET_NAME('MSC','MSC_CL_ERR_PDC_2');
5813: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
5814: ELSIF (var_debug = 4) THEN
5815: FND_MESSAGE.SET_NAME('MSC','MSC_CL_ERR_PDC_3');
5816: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
5817: ELSIF (var_debug = 5) THEN

Line 5815: FND_MESSAGE.SET_NAME('MSC','MSC_CL_ERR_PDC_3');

5811: ELSIF (var_debug = 3) THEN
5812: FND_MESSAGE.SET_NAME('MSC','MSC_CL_ERR_PDC_2');
5813: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
5814: ELSIF (var_debug = 4) THEN
5815: FND_MESSAGE.SET_NAME('MSC','MSC_CL_ERR_PDC_3');
5816: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
5817: ELSIF (var_debug = 5) THEN
5818: FND_MESSAGE.SET_NAME('MSC','MSC_CL_ERR_PDC_4');
5819: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);

Line 5816: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);

5812: FND_MESSAGE.SET_NAME('MSC','MSC_CL_ERR_PDC_2');
5813: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
5814: ELSIF (var_debug = 4) THEN
5815: FND_MESSAGE.SET_NAME('MSC','MSC_CL_ERR_PDC_3');
5816: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
5817: ELSIF (var_debug = 5) THEN
5818: FND_MESSAGE.SET_NAME('MSC','MSC_CL_ERR_PDC_4');
5819: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
5820:

Line 5818: FND_MESSAGE.SET_NAME('MSC','MSC_CL_ERR_PDC_4');

5814: ELSIF (var_debug = 4) THEN
5815: FND_MESSAGE.SET_NAME('MSC','MSC_CL_ERR_PDC_3');
5816: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
5817: ELSIF (var_debug = 5) THEN
5818: FND_MESSAGE.SET_NAME('MSC','MSC_CL_ERR_PDC_4');
5819: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
5820:
5821: END IF;
5822:

Line 5819: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);

5815: FND_MESSAGE.SET_NAME('MSC','MSC_CL_ERR_PDC_3');
5816: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
5817: ELSIF (var_debug = 5) THEN
5818: FND_MESSAGE.SET_NAME('MSC','MSC_CL_ERR_PDC_4');
5819: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
5820:
5821: END IF;
5822:
5823: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, '----------------------------------------------------');

Line 5834: FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_FAIL');

5830: lv_task_number:= -1;
5831:
5832: ROLLBACK;
5833:
5834: FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_FAIL');
5835: ERRBUF:= FND_MESSAGE.GET;
5836: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, ERRBUF);
5837:
5838: RETCODE := MSC_UTIL.G_ERROR;

Line 5835: ERRBUF:= FND_MESSAGE.GET;

5831:
5832: ROLLBACK;
5833:
5834: FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_FAIL');
5835: ERRBUF:= FND_MESSAGE.GET;
5836: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, ERRBUF);
5837:
5838: RETCODE := MSC_UTIL.G_ERROR;
5839:

Line 5871: FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_SUCCEED');

5867: RETCODE := MSC_UTIL.G_ERROR;
5868: END IF;
5869: END IF; -- partial_refresh
5870:
5871: FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_SUCCEED');
5872: ERRBUF:= FND_MESSAGE.GET;
5873: RETCODE := MSC_UTIL.G_SUCCESS ;
5874: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, ERRBUF);
5875:

Line 5872: ERRBUF:= FND_MESSAGE.GET;

5868: END IF;
5869: END IF; -- partial_refresh
5870:
5871: FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_SUCCEED');
5872: ERRBUF:= FND_MESSAGE.GET;
5873: RETCODE := MSC_UTIL.G_SUCCESS ;
5874: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, ERRBUF);
5875:
5876: END IF;

Line 5892: FND_MESSAGE.SET_NAME('MSC','MSC_CL_SEND_WOR_END');

5888: -- Exit the workers
5889:
5890: FOR lc_i IN 1..pTotalWorkerNum LOOP
5891:
5892: FND_MESSAGE.SET_NAME('MSC','MSC_CL_SEND_WOR_END');
5893: FND_MESSAGE.SET_TOKEN('LCI',lc_i);
5894: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
5895:
5896: DBMS_PIPE.PACK_MESSAGE( lv_task_number);

Line 5893: FND_MESSAGE.SET_TOKEN('LCI',lc_i);

5889:
5890: FOR lc_i IN 1..pTotalWorkerNum LOOP
5891:
5892: FND_MESSAGE.SET_NAME('MSC','MSC_CL_SEND_WOR_END');
5893: FND_MESSAGE.SET_TOKEN('LCI',lc_i);
5894: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
5895:
5896: DBMS_PIPE.PACK_MESSAGE( lv_task_number);
5897:

Line 5894: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

5890: FOR lc_i IN 1..pTotalWorkerNum LOOP
5891:
5892: FND_MESSAGE.SET_NAME('MSC','MSC_CL_SEND_WOR_END');
5893: FND_MESSAGE.SET_TOKEN('LCI',lc_i);
5894: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
5895:
5896: DBMS_PIPE.PACK_MESSAGE( lv_task_number);
5897:
5898: MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'Sending task number: '||lv_task_number||' to the worker '||lc_i);

Line 5919: FND_MESSAGE.SET_NAME('MSC','MSC_CL_WORKER_COMMIT');

5915: IF lv_pipe_ret_code=0 THEN
5916:
5917: lv_worker_committed:= lv_worker_committed+1;
5918:
5919: FND_MESSAGE.SET_NAME('MSC','MSC_CL_WORKER_COMMIT');
5920: FND_MESSAGE.SET_TOKEN('LV_WORKER_COMMITTED',lv_worker_committed);
5921: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
5922:
5923: EXIT WHEN lv_worker_committed= pTotalWorkerNum;

Line 5920: FND_MESSAGE.SET_TOKEN('LV_WORKER_COMMITTED',lv_worker_committed);

5916:
5917: lv_worker_committed:= lv_worker_committed+1;
5918:
5919: FND_MESSAGE.SET_NAME('MSC','MSC_CL_WORKER_COMMIT');
5920: FND_MESSAGE.SET_TOKEN('LV_WORKER_COMMITTED',lv_worker_committed);
5921: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
5922:
5923: EXIT WHEN lv_worker_committed= pTotalWorkerNum;
5924:

Line 5921: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

5917: lv_worker_committed:= lv_worker_committed+1;
5918:
5919: FND_MESSAGE.SET_NAME('MSC','MSC_CL_WORKER_COMMIT');
5920: FND_MESSAGE.SET_TOKEN('LV_WORKER_COMMITTED',lv_worker_committed);
5921: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
5922:
5923: EXIT WHEN lv_worker_committed= pTotalWorkerNum;
5924:
5925: ELSIF lv_pipe_ret_code<> 1 THEN

Line 5940: FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_FAIL_TO_COMMIT');

5936: END LOOP;
5937:
5938: IF lv_worker_committed<> pTotalWorkerNum THEN
5939:
5940: FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_FAIL_TO_COMMIT');
5941: ERRBUF:= FND_MESSAGE.GET;
5942: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, ERRBUF);
5943: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, SQLERRM);
5944:

Line 5941: ERRBUF:= FND_MESSAGE.GET;

5937:
5938: IF lv_worker_committed<> pTotalWorkerNum THEN
5939:
5940: FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_FAIL_TO_COMMIT');
5941: ERRBUF:= FND_MESSAGE.GET;
5942: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, ERRBUF);
5943: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, SQLERRM);
5944:
5945: FND_MESSAGE.SET_NAME('MSC','MSC_CL_CHECK_PDC_LOG');

Line 5945: FND_MESSAGE.SET_NAME('MSC','MSC_CL_CHECK_PDC_LOG');

5941: ERRBUF:= FND_MESSAGE.GET;
5942: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, ERRBUF);
5943: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, SQLERRM);
5944:
5945: FND_MESSAGE.SET_NAME('MSC','MSC_CL_CHECK_PDC_LOG');
5946: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
5947:
5948: RETCODE := MSC_UTIL.G_ERROR;
5949: ELSE

Line 5946: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);

5942: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, ERRBUF);
5943: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, SQLERRM);
5944:
5945: FND_MESSAGE.SET_NAME('MSC','MSC_CL_CHECK_PDC_LOG');
5946: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
5947:
5948: RETCODE := MSC_UTIL.G_ERROR;
5949: ELSE
5950: IF lv_task_number= 0 THEN

Line 5957: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');

5953: (v_is_cont_refresh AND (v_coll_prec.po_flag = MSC_UTIL.SYS_YES and v_coll_prec.po_sn_flag = MSC_UTIL.SYS_TGT)
5954: AND v_coll_prec.sales_order_flag =MSC_UTIL.SYS_NO) THEN
5955: IF ( v_apps_ver >= MSC_UTIL.G_APPS115 ) THEN
5956: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, ' Calling Linking of Sales Order for 11i source ...');
5957: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
5958: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LINK_SUPP_SO_DEMAND_11I2');
5959: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
5960: MSC_CL_DEMAND_ODS_LOAD.LINK_SUPP_SO_DEMAND_11I2;
5961: END IF;

Line 5958: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LINK_SUPP_SO_DEMAND_11I2');

5954: AND v_coll_prec.sales_order_flag =MSC_UTIL.SYS_NO) THEN
5955: IF ( v_apps_ver >= MSC_UTIL.G_APPS115 ) THEN
5956: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, ' Calling Linking of Sales Order for 11i source ...');
5957: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
5958: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LINK_SUPP_SO_DEMAND_11I2');
5959: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
5960: MSC_CL_DEMAND_ODS_LOAD.LINK_SUPP_SO_DEMAND_11I2;
5961: END IF;
5962: END IF;

Line 5959: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

5955: IF ( v_apps_ver >= MSC_UTIL.G_APPS115 ) THEN
5956: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, ' Calling Linking of Sales Order for 11i source ...');
5957: FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
5958: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LINK_SUPP_SO_DEMAND_11I2');
5959: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
5960: MSC_CL_DEMAND_ODS_LOAD.LINK_SUPP_SO_DEMAND_11I2;
5961: END IF;
5962: END IF;
5963:

Line 6095: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');

6091: IF (v_req_ext_po_so_linking) Then
6092: IF ( v_apps_ver >= MSC_UTIL.G_APPS115 ) THEN
6093: BEGIN
6094: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, ' Calling Linking of Sales Order for 11i source ...');
6095: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
6096: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LINK_SUPP_SO_DEMAND_EXT');
6097: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
6098: -- Calling the Linking of external Sales orders for the fix 2353397 --
6099: MSC_CL_DEMAND_ODS_LOAD.LINK_SUPP_SO_DEMAND_EXT;

Line 6096: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LINK_SUPP_SO_DEMAND_EXT');

6092: IF ( v_apps_ver >= MSC_UTIL.G_APPS115 ) THEN
6093: BEGIN
6094: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, ' Calling Linking of Sales Order for 11i source ...');
6095: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
6096: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LINK_SUPP_SO_DEMAND_EXT');
6097: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
6098: -- Calling the Linking of external Sales orders for the fix 2353397 --
6099: MSC_CL_DEMAND_ODS_LOAD.LINK_SUPP_SO_DEMAND_EXT;
6100: END;

Line 6097: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

6093: BEGIN
6094: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, ' Calling Linking of Sales Order for 11i source ...');
6095: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
6096: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LINK_SUPP_SO_DEMAND_EXT');
6097: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
6098: -- Calling the Linking of external Sales orders for the fix 2353397 --
6099: MSC_CL_DEMAND_ODS_LOAD.LINK_SUPP_SO_DEMAND_EXT;
6100: END;
6101:

Line 6192: FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_CALC_RES_AVAIL_FAIL');

6188: lv_ret_res_ava:=MSC_RESOURCE_AVAILABILITY.CALC_RESOURCE_AVAILABILITY(v_resource_start_time,v_coll_prec.org_group_flag,FALSE);
6189:
6190:
6191: IF lv_ret_res_ava = 2 THEN
6192: FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_CALC_RES_AVAIL_FAIL');
6193: ERRBUF:= FND_MESSAGE.GET;
6194: v_warning_flag:=MSC_UTIL.SYS_YES;
6195: ELSIF lv_ret_res_ava <> 0 THEN
6196: FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_CALC_RES_AVAIL_FAIL');

Line 6193: ERRBUF:= FND_MESSAGE.GET;

6189:
6190:
6191: IF lv_ret_res_ava = 2 THEN
6192: FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_CALC_RES_AVAIL_FAIL');
6193: ERRBUF:= FND_MESSAGE.GET;
6194: v_warning_flag:=MSC_UTIL.SYS_YES;
6195: ELSIF lv_ret_res_ava <> 0 THEN
6196: FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_CALC_RES_AVAIL_FAIL');
6197: ERRBUF:= FND_MESSAGE.GET;

Line 6196: FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_CALC_RES_AVAIL_FAIL');

6192: FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_CALC_RES_AVAIL_FAIL');
6193: ERRBUF:= FND_MESSAGE.GET;
6194: v_warning_flag:=MSC_UTIL.SYS_YES;
6195: ELSIF lv_ret_res_ava <> 0 THEN
6196: FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_CALC_RES_AVAIL_FAIL');
6197: ERRBUF:= FND_MESSAGE.GET;
6198: RETCODE:= MSC_UTIL.G_ERROR;
6199:
6200: -- ROLLBACK WORK TO SAVEPOINT WORKERS_COMMITTED;

Line 6197: ERRBUF:= FND_MESSAGE.GET;

6193: ERRBUF:= FND_MESSAGE.GET;
6194: v_warning_flag:=MSC_UTIL.SYS_YES;
6195: ELSIF lv_ret_res_ava <> 0 THEN
6196: FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_CALC_RES_AVAIL_FAIL');
6197: ERRBUF:= FND_MESSAGE.GET;
6198: RETCODE:= MSC_UTIL.G_ERROR;
6199:
6200: -- ROLLBACK WORK TO SAVEPOINT WORKERS_COMMITTED;
6201: END IF;

Line 6526: FND_MESSAGE.SET_NAME('MSC', 'MSC_MSG_SEND_FAIL');

6522: NULL;
6523: END IF;
6524: END IF;
6525:
6526: FND_MESSAGE.SET_NAME('MSC', 'MSC_MSG_SEND_FAIL');
6527: FND_MESSAGE.SET_TOKEN('PIPE', v_pipe_wm);
6528: ERRBUF:= FND_MESSAGE.GET;
6529:
6530: --Rollback swap partitions

Line 6527: FND_MESSAGE.SET_TOKEN('PIPE', v_pipe_wm);

6523: END IF;
6524: END IF;
6525:
6526: FND_MESSAGE.SET_NAME('MSC', 'MSC_MSG_SEND_FAIL');
6527: FND_MESSAGE.SET_TOKEN('PIPE', v_pipe_wm);
6528: ERRBUF:= FND_MESSAGE.GET;
6529:
6530: --Rollback swap partitions
6531: IF NOT MSC_CL_EXCHANGE_PARTTBL.UNDO_STG_ODS_SWAP THEN

Line 6528: ERRBUF:= FND_MESSAGE.GET;

6524: END IF;
6525:
6526: FND_MESSAGE.SET_NAME('MSC', 'MSC_MSG_SEND_FAIL');
6527: FND_MESSAGE.SET_TOKEN('PIPE', v_pipe_wm);
6528: ERRBUF:= FND_MESSAGE.GET;
6529:
6530: --Rollback swap partitions
6531: IF NOT MSC_CL_EXCHANGE_PARTTBL.UNDO_STG_ODS_SWAP THEN
6532: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR,' Exchange partition failed ');

Line 6553: FND_MESSAGE.SET_NAME('MSC', 'MSC_TIMEOUT');

6549: NULL;
6550: END IF;
6551: END IF;
6552:
6553: FND_MESSAGE.SET_NAME('MSC', 'MSC_TIMEOUT');
6554: ERRBUF:= FND_MESSAGE.GET;
6555:
6556: --Rollback swap partitions
6557: IF NOT MSC_CL_EXCHANGE_PARTTBL.UNDO_STG_ODS_SWAP THEN

Line 6554: ERRBUF:= FND_MESSAGE.GET;

6550: END IF;
6551: END IF;
6552:
6553: FND_MESSAGE.SET_NAME('MSC', 'MSC_TIMEOUT');
6554: ERRBUF:= FND_MESSAGE.GET;
6555:
6556: --Rollback swap partitions
6557: IF NOT MSC_CL_EXCHANGE_PARTTBL.UNDO_STG_ODS_SWAP THEN
6558: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR,' Exchange partition failed ');

Line 6753: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');

6749: EXCHG_PRT_ERROR EXCEPTION;
6750:
6751: BEGIN
6752:
6753: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
6754: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'alter_temp_table');
6755: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
6756:
6757: SELECT instance_id

Line 6754: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'alter_temp_table');

6750:
6751: BEGIN
6752:
6753: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
6754: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'alter_temp_table');
6755: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
6756:
6757: SELECT instance_id
6758: INTO lv_instance_id

Line 6755: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);

6751: BEGIN
6752:
6753: FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
6754: FND_MESSAGE.SET_TOKEN('PROCEDURE', 'alter_temp_table');
6755: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
6756:
6757: SELECT instance_id
6758: INTO lv_instance_id
6759: FROM msc_apps_instances

Line 6787: FND_MESSAGE.SET_NAME('MSC', 'MSC_CRT_IND_STATUS');

6783: p_severity_level
6784: );
6785:
6786: IF lv_crt_ind_status = MSC_UTIL.G_ERROR THEN
6787: FND_MESSAGE.SET_NAME('MSC', 'MSC_CRT_IND_STATUS');
6788: FND_MESSAGE.SET_TOKEN('UNIQUENESS', 'UNIQUE');
6789: FND_MESSAGE.SET_TOKEN('TABLE_NAME', lv_temp_tbl_name);
6790: FND_MESSAGE.SET_TOKEN('STATUS', 'ERROR');
6791:

Line 6788: FND_MESSAGE.SET_TOKEN('UNIQUENESS', 'UNIQUE');

6784: );
6785:
6786: IF lv_crt_ind_status = MSC_UTIL.G_ERROR THEN
6787: FND_MESSAGE.SET_NAME('MSC', 'MSC_CRT_IND_STATUS');
6788: FND_MESSAGE.SET_TOKEN('UNIQUENESS', 'UNIQUE');
6789: FND_MESSAGE.SET_TOKEN('TABLE_NAME', lv_temp_tbl_name);
6790: FND_MESSAGE.SET_TOKEN('STATUS', 'ERROR');
6791:
6792: lv_errbuf := FND_MESSAGE.GET;

Line 6789: FND_MESSAGE.SET_TOKEN('TABLE_NAME', lv_temp_tbl_name);

6785:
6786: IF lv_crt_ind_status = MSC_UTIL.G_ERROR THEN
6787: FND_MESSAGE.SET_NAME('MSC', 'MSC_CRT_IND_STATUS');
6788: FND_MESSAGE.SET_TOKEN('UNIQUENESS', 'UNIQUE');
6789: FND_MESSAGE.SET_TOKEN('TABLE_NAME', lv_temp_tbl_name);
6790: FND_MESSAGE.SET_TOKEN('STATUS', 'ERROR');
6791:
6792: lv_errbuf := FND_MESSAGE.GET;
6793: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, lv_errbuf);

Line 6790: FND_MESSAGE.SET_TOKEN('STATUS', 'ERROR');

6786: IF lv_crt_ind_status = MSC_UTIL.G_ERROR THEN
6787: FND_MESSAGE.SET_NAME('MSC', 'MSC_CRT_IND_STATUS');
6788: FND_MESSAGE.SET_TOKEN('UNIQUENESS', 'UNIQUE');
6789: FND_MESSAGE.SET_TOKEN('TABLE_NAME', lv_temp_tbl_name);
6790: FND_MESSAGE.SET_TOKEN('STATUS', 'ERROR');
6791:
6792: lv_errbuf := FND_MESSAGE.GET;
6793: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, lv_errbuf);
6794: RAISE INDEX_CREATION_ERROR;

Line 6792: lv_errbuf := FND_MESSAGE.GET;

6788: FND_MESSAGE.SET_TOKEN('UNIQUENESS', 'UNIQUE');
6789: FND_MESSAGE.SET_TOKEN('TABLE_NAME', lv_temp_tbl_name);
6790: FND_MESSAGE.SET_TOKEN('STATUS', 'ERROR');
6791:
6792: lv_errbuf := FND_MESSAGE.GET;
6793: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, lv_errbuf);
6794: RAISE INDEX_CREATION_ERROR;
6795: ELSE
6796: IF lv_crt_ind_status = MSC_UTIL.G_WARNING THEN

Line 6797: FND_MESSAGE.SET_NAME('MSC', 'MSC_CRT_IND_STATUS');

6793: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, lv_errbuf);
6794: RAISE INDEX_CREATION_ERROR;
6795: ELSE
6796: IF lv_crt_ind_status = MSC_UTIL.G_WARNING THEN
6797: FND_MESSAGE.SET_NAME('MSC', 'MSC_CRT_IND_STATUS');
6798: FND_MESSAGE.SET_TOKEN('UNIQUENESS', 'UNIQUE');
6799: FND_MESSAGE.SET_TOKEN('TABLE_NAME', lv_temp_tbl_name);
6800: FND_MESSAGE.SET_TOKEN('STATUS', 'WARNING');
6801:

Line 6798: FND_MESSAGE.SET_TOKEN('UNIQUENESS', 'UNIQUE');

6794: RAISE INDEX_CREATION_ERROR;
6795: ELSE
6796: IF lv_crt_ind_status = MSC_UTIL.G_WARNING THEN
6797: FND_MESSAGE.SET_NAME('MSC', 'MSC_CRT_IND_STATUS');
6798: FND_MESSAGE.SET_TOKEN('UNIQUENESS', 'UNIQUE');
6799: FND_MESSAGE.SET_TOKEN('TABLE_NAME', lv_temp_tbl_name);
6800: FND_MESSAGE.SET_TOKEN('STATUS', 'WARNING');
6801:
6802: lv_errbuf := FND_MESSAGE.GET;

Line 6799: FND_MESSAGE.SET_TOKEN('TABLE_NAME', lv_temp_tbl_name);

6795: ELSE
6796: IF lv_crt_ind_status = MSC_UTIL.G_WARNING THEN
6797: FND_MESSAGE.SET_NAME('MSC', 'MSC_CRT_IND_STATUS');
6798: FND_MESSAGE.SET_TOKEN('UNIQUENESS', 'UNIQUE');
6799: FND_MESSAGE.SET_TOKEN('TABLE_NAME', lv_temp_tbl_name);
6800: FND_MESSAGE.SET_TOKEN('STATUS', 'WARNING');
6801:
6802: lv_errbuf := FND_MESSAGE.GET;
6803: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, lv_errbuf);

Line 6800: FND_MESSAGE.SET_TOKEN('STATUS', 'WARNING');

6796: IF lv_crt_ind_status = MSC_UTIL.G_WARNING THEN
6797: FND_MESSAGE.SET_NAME('MSC', 'MSC_CRT_IND_STATUS');
6798: FND_MESSAGE.SET_TOKEN('UNIQUENESS', 'UNIQUE');
6799: FND_MESSAGE.SET_TOKEN('TABLE_NAME', lv_temp_tbl_name);
6800: FND_MESSAGE.SET_TOKEN('STATUS', 'WARNING');
6801:
6802: lv_errbuf := FND_MESSAGE.GET;
6803: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, lv_errbuf);
6804: lv_retcode := MSC_UTIL.G_WARNING;

Line 6802: lv_errbuf := FND_MESSAGE.GET;

6798: FND_MESSAGE.SET_TOKEN('UNIQUENESS', 'UNIQUE');
6799: FND_MESSAGE.SET_TOKEN('TABLE_NAME', lv_temp_tbl_name);
6800: FND_MESSAGE.SET_TOKEN('STATUS', 'WARNING');
6801:
6802: lv_errbuf := FND_MESSAGE.GET;
6803: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, lv_errbuf);
6804: lv_retcode := MSC_UTIL.G_WARNING;
6805: ELSE
6806: FND_MESSAGE.SET_NAME('MSC', 'MSC_CRT_IND_STATUS');

Line 6806: FND_MESSAGE.SET_NAME('MSC', 'MSC_CRT_IND_STATUS');

6802: lv_errbuf := FND_MESSAGE.GET;
6803: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, lv_errbuf);
6804: lv_retcode := MSC_UTIL.G_WARNING;
6805: ELSE
6806: FND_MESSAGE.SET_NAME('MSC', 'MSC_CRT_IND_STATUS');
6807: FND_MESSAGE.SET_TOKEN('UNIQUENESS', 'UNIQUE');
6808: FND_MESSAGE.SET_TOKEN('TABLE_NAME', lv_temp_tbl_name);
6809: FND_MESSAGE.SET_TOKEN('STATUS', 'SUCCESS');
6810:

Line 6807: FND_MESSAGE.SET_TOKEN('UNIQUENESS', 'UNIQUE');

6803: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, lv_errbuf);
6804: lv_retcode := MSC_UTIL.G_WARNING;
6805: ELSE
6806: FND_MESSAGE.SET_NAME('MSC', 'MSC_CRT_IND_STATUS');
6807: FND_MESSAGE.SET_TOKEN('UNIQUENESS', 'UNIQUE');
6808: FND_MESSAGE.SET_TOKEN('TABLE_NAME', lv_temp_tbl_name);
6809: FND_MESSAGE.SET_TOKEN('STATUS', 'SUCCESS');
6810:
6811: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS,FND_MESSAGE.GET);

Line 6808: FND_MESSAGE.SET_TOKEN('TABLE_NAME', lv_temp_tbl_name);

6804: lv_retcode := MSC_UTIL.G_WARNING;
6805: ELSE
6806: FND_MESSAGE.SET_NAME('MSC', 'MSC_CRT_IND_STATUS');
6807: FND_MESSAGE.SET_TOKEN('UNIQUENESS', 'UNIQUE');
6808: FND_MESSAGE.SET_TOKEN('TABLE_NAME', lv_temp_tbl_name);
6809: FND_MESSAGE.SET_TOKEN('STATUS', 'SUCCESS');
6810:
6811: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS,FND_MESSAGE.GET);
6812: END IF;

Line 6809: FND_MESSAGE.SET_TOKEN('STATUS', 'SUCCESS');

6805: ELSE
6806: FND_MESSAGE.SET_NAME('MSC', 'MSC_CRT_IND_STATUS');
6807: FND_MESSAGE.SET_TOKEN('UNIQUENESS', 'UNIQUE');
6808: FND_MESSAGE.SET_TOKEN('TABLE_NAME', lv_temp_tbl_name);
6809: FND_MESSAGE.SET_TOKEN('STATUS', 'SUCCESS');
6810:
6811: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS,FND_MESSAGE.GET);
6812: END IF;
6813:

Line 6811: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS,FND_MESSAGE.GET);

6807: FND_MESSAGE.SET_TOKEN('UNIQUENESS', 'UNIQUE');
6808: FND_MESSAGE.SET_TOKEN('TABLE_NAME', lv_temp_tbl_name);
6809: FND_MESSAGE.SET_TOKEN('STATUS', 'SUCCESS');
6810:
6811: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS,FND_MESSAGE.GET);
6812: END IF;
6813:
6814: lv_crt_ind_status := MSC_CL_EXCHANGE_PARTTBL.create_temp_table_index
6815: ('NONUNIQUE',

Line 6824: FND_MESSAGE.SET_NAME('MSC', 'MSC_CRT_IND_STATUS');

6820: lv_is_plan,
6821: p_severity_level
6822: );
6823: IF lv_crt_ind_status = MSC_UTIL.G_WARNING THEN
6824: FND_MESSAGE.SET_NAME('MSC', 'MSC_CRT_IND_STATUS');
6825: FND_MESSAGE.SET_TOKEN('UNIQUENESS', 'NONUNIQUE');
6826: FND_MESSAGE.SET_TOKEN('TABLE_NAME', lv_temp_tbl_name);
6827: FND_MESSAGE.SET_TOKEN('STATUS', 'WARNING');
6828:

Line 6825: FND_MESSAGE.SET_TOKEN('UNIQUENESS', 'NONUNIQUE');

6821: p_severity_level
6822: );
6823: IF lv_crt_ind_status = MSC_UTIL.G_WARNING THEN
6824: FND_MESSAGE.SET_NAME('MSC', 'MSC_CRT_IND_STATUS');
6825: FND_MESSAGE.SET_TOKEN('UNIQUENESS', 'NONUNIQUE');
6826: FND_MESSAGE.SET_TOKEN('TABLE_NAME', lv_temp_tbl_name);
6827: FND_MESSAGE.SET_TOKEN('STATUS', 'WARNING');
6828:
6829: lv_errbuf := FND_MESSAGE.GET;

Line 6826: FND_MESSAGE.SET_TOKEN('TABLE_NAME', lv_temp_tbl_name);

6822: );
6823: IF lv_crt_ind_status = MSC_UTIL.G_WARNING THEN
6824: FND_MESSAGE.SET_NAME('MSC', 'MSC_CRT_IND_STATUS');
6825: FND_MESSAGE.SET_TOKEN('UNIQUENESS', 'NONUNIQUE');
6826: FND_MESSAGE.SET_TOKEN('TABLE_NAME', lv_temp_tbl_name);
6827: FND_MESSAGE.SET_TOKEN('STATUS', 'WARNING');
6828:
6829: lv_errbuf := FND_MESSAGE.GET;
6830: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, lv_errbuf);

Line 6827: FND_MESSAGE.SET_TOKEN('STATUS', 'WARNING');

6823: IF lv_crt_ind_status = MSC_UTIL.G_WARNING THEN
6824: FND_MESSAGE.SET_NAME('MSC', 'MSC_CRT_IND_STATUS');
6825: FND_MESSAGE.SET_TOKEN('UNIQUENESS', 'NONUNIQUE');
6826: FND_MESSAGE.SET_TOKEN('TABLE_NAME', lv_temp_tbl_name);
6827: FND_MESSAGE.SET_TOKEN('STATUS', 'WARNING');
6828:
6829: lv_errbuf := FND_MESSAGE.GET;
6830: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, lv_errbuf);
6831: lv_retcode := MSC_UTIL.G_WARNING;

Line 6829: lv_errbuf := FND_MESSAGE.GET;

6825: FND_MESSAGE.SET_TOKEN('UNIQUENESS', 'NONUNIQUE');
6826: FND_MESSAGE.SET_TOKEN('TABLE_NAME', lv_temp_tbl_name);
6827: FND_MESSAGE.SET_TOKEN('STATUS', 'WARNING');
6828:
6829: lv_errbuf := FND_MESSAGE.GET;
6830: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, lv_errbuf);
6831: lv_retcode := MSC_UTIL.G_WARNING;
6832: ELSIF lv_crt_ind_status = MSC_UTIL.G_ERROR THEN
6833: FND_MESSAGE.SET_NAME('MSC', 'MSC_CRT_IND_STATUS');

Line 6833: FND_MESSAGE.SET_NAME('MSC', 'MSC_CRT_IND_STATUS');

6829: lv_errbuf := FND_MESSAGE.GET;
6830: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, lv_errbuf);
6831: lv_retcode := MSC_UTIL.G_WARNING;
6832: ELSIF lv_crt_ind_status = MSC_UTIL.G_ERROR THEN
6833: FND_MESSAGE.SET_NAME('MSC', 'MSC_CRT_IND_STATUS');
6834: FND_MESSAGE.SET_TOKEN('UNIQUENESS', 'NONUNIQUE');
6835: FND_MESSAGE.SET_TOKEN('TABLE_NAME', lv_temp_tbl_name);
6836: FND_MESSAGE.SET_TOKEN('STATUS', 'ERROR');
6837:

Line 6834: FND_MESSAGE.SET_TOKEN('UNIQUENESS', 'NONUNIQUE');

6830: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, lv_errbuf);
6831: lv_retcode := MSC_UTIL.G_WARNING;
6832: ELSIF lv_crt_ind_status = MSC_UTIL.G_ERROR THEN
6833: FND_MESSAGE.SET_NAME('MSC', 'MSC_CRT_IND_STATUS');
6834: FND_MESSAGE.SET_TOKEN('UNIQUENESS', 'NONUNIQUE');
6835: FND_MESSAGE.SET_TOKEN('TABLE_NAME', lv_temp_tbl_name);
6836: FND_MESSAGE.SET_TOKEN('STATUS', 'ERROR');
6837:
6838: lv_errbuf := FND_MESSAGE.GET;

Line 6835: FND_MESSAGE.SET_TOKEN('TABLE_NAME', lv_temp_tbl_name);

6831: lv_retcode := MSC_UTIL.G_WARNING;
6832: ELSIF lv_crt_ind_status = MSC_UTIL.G_ERROR THEN
6833: FND_MESSAGE.SET_NAME('MSC', 'MSC_CRT_IND_STATUS');
6834: FND_MESSAGE.SET_TOKEN('UNIQUENESS', 'NONUNIQUE');
6835: FND_MESSAGE.SET_TOKEN('TABLE_NAME', lv_temp_tbl_name);
6836: FND_MESSAGE.SET_TOKEN('STATUS', 'ERROR');
6837:
6838: lv_errbuf := FND_MESSAGE.GET;
6839: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, lv_errbuf);

Line 6836: FND_MESSAGE.SET_TOKEN('STATUS', 'ERROR');

6832: ELSIF lv_crt_ind_status = MSC_UTIL.G_ERROR THEN
6833: FND_MESSAGE.SET_NAME('MSC', 'MSC_CRT_IND_STATUS');
6834: FND_MESSAGE.SET_TOKEN('UNIQUENESS', 'NONUNIQUE');
6835: FND_MESSAGE.SET_TOKEN('TABLE_NAME', lv_temp_tbl_name);
6836: FND_MESSAGE.SET_TOKEN('STATUS', 'ERROR');
6837:
6838: lv_errbuf := FND_MESSAGE.GET;
6839: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, lv_errbuf);
6840: RAISE INDEX_CREATION_ERROR;

Line 6838: lv_errbuf := FND_MESSAGE.GET;

6834: FND_MESSAGE.SET_TOKEN('UNIQUENESS', 'NONUNIQUE');
6835: FND_MESSAGE.SET_TOKEN('TABLE_NAME', lv_temp_tbl_name);
6836: FND_MESSAGE.SET_TOKEN('STATUS', 'ERROR');
6837:
6838: lv_errbuf := FND_MESSAGE.GET;
6839: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, lv_errbuf);
6840: RAISE INDEX_CREATION_ERROR;
6841: ELSE
6842: FND_MESSAGE.SET_NAME('MSC', 'MSC_CRT_IND_STATUS');

Line 6842: FND_MESSAGE.SET_NAME('MSC', 'MSC_CRT_IND_STATUS');

6838: lv_errbuf := FND_MESSAGE.GET;
6839: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, lv_errbuf);
6840: RAISE INDEX_CREATION_ERROR;
6841: ELSE
6842: FND_MESSAGE.SET_NAME('MSC', 'MSC_CRT_IND_STATUS');
6843: FND_MESSAGE.SET_TOKEN('UNIQUENESS', 'NONUNIQUE');
6844: FND_MESSAGE.SET_TOKEN('TABLE_NAME', lv_temp_tbl_name);
6845: FND_MESSAGE.SET_TOKEN('STATUS', 'SUCCESS');
6846:

Line 6843: FND_MESSAGE.SET_TOKEN('UNIQUENESS', 'NONUNIQUE');

6839: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, lv_errbuf);
6840: RAISE INDEX_CREATION_ERROR;
6841: ELSE
6842: FND_MESSAGE.SET_NAME('MSC', 'MSC_CRT_IND_STATUS');
6843: FND_MESSAGE.SET_TOKEN('UNIQUENESS', 'NONUNIQUE');
6844: FND_MESSAGE.SET_TOKEN('TABLE_NAME', lv_temp_tbl_name);
6845: FND_MESSAGE.SET_TOKEN('STATUS', 'SUCCESS');
6846:
6847: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS,FND_MESSAGE.GET);

Line 6844: FND_MESSAGE.SET_TOKEN('TABLE_NAME', lv_temp_tbl_name);

6840: RAISE INDEX_CREATION_ERROR;
6841: ELSE
6842: FND_MESSAGE.SET_NAME('MSC', 'MSC_CRT_IND_STATUS');
6843: FND_MESSAGE.SET_TOKEN('UNIQUENESS', 'NONUNIQUE');
6844: FND_MESSAGE.SET_TOKEN('TABLE_NAME', lv_temp_tbl_name);
6845: FND_MESSAGE.SET_TOKEN('STATUS', 'SUCCESS');
6846:
6847: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS,FND_MESSAGE.GET);
6848: END IF;

Line 6845: FND_MESSAGE.SET_TOKEN('STATUS', 'SUCCESS');

6841: ELSE
6842: FND_MESSAGE.SET_NAME('MSC', 'MSC_CRT_IND_STATUS');
6843: FND_MESSAGE.SET_TOKEN('UNIQUENESS', 'NONUNIQUE');
6844: FND_MESSAGE.SET_TOKEN('TABLE_NAME', lv_temp_tbl_name);
6845: FND_MESSAGE.SET_TOKEN('STATUS', 'SUCCESS');
6846:
6847: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS,FND_MESSAGE.GET);
6848: END IF;
6849: END IF;

Line 6847: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS,FND_MESSAGE.GET);

6843: FND_MESSAGE.SET_TOKEN('UNIQUENESS', 'NONUNIQUE');
6844: FND_MESSAGE.SET_TOKEN('TABLE_NAME', lv_temp_tbl_name);
6845: FND_MESSAGE.SET_TOKEN('STATUS', 'SUCCESS');
6846:
6847: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS,FND_MESSAGE.GET);
6848: END IF;
6849: END IF;
6850:
6851: FND_MESSAGE.SET_NAME('MSC', 'MSC_CRT_IND_STATUS');

Line 6851: FND_MESSAGE.SET_NAME('MSC', 'MSC_CRT_IND_STATUS');

6847: MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS,FND_MESSAGE.GET);
6848: END IF;
6849: END IF;
6850:
6851: FND_MESSAGE.SET_NAME('MSC', 'MSC_CRT_IND_STATUS');
6852: FND_MESSAGE.SET_TOKEN('UNIQUENESS', 'Unique and Nonunique');
6853: FND_MESSAGE.SET_TOKEN('TABLE_NAME', lv_temp_tbl_name);
6854: FND_MESSAGE.SET_TOKEN('STATUS', 'SUCCESS');
6855:

Line 6852: FND_MESSAGE.SET_TOKEN('UNIQUENESS', 'Unique and Nonunique');

6848: END IF;
6849: END IF;
6850:
6851: FND_MESSAGE.SET_NAME('MSC', 'MSC_CRT_IND_STATUS');
6852: FND_MESSAGE.SET_TOKEN('UNIQUENESS', 'Unique and Nonunique');
6853: FND_MESSAGE.SET_TOKEN('TABLE_NAME', lv_temp_tbl_name);
6854: FND_MESSAGE.SET_TOKEN('STATUS', 'SUCCESS');
6855:
6856: lv_errbuf := FND_MESSAGE.GET;

Line 6853: FND_MESSAGE.SET_TOKEN('TABLE_NAME', lv_temp_tbl_name);

6849: END IF;
6850:
6851: FND_MESSAGE.SET_NAME('MSC', 'MSC_CRT_IND_STATUS');
6852: FND_MESSAGE.SET_TOKEN('UNIQUENESS', 'Unique and Nonunique');
6853: FND_MESSAGE.SET_TOKEN('TABLE_NAME', lv_temp_tbl_name);
6854: FND_MESSAGE.SET_TOKEN('STATUS', 'SUCCESS');
6855:
6856: lv_errbuf := FND_MESSAGE.GET;
6857:

Line 6854: FND_MESSAGE.SET_TOKEN('STATUS', 'SUCCESS');

6850:
6851: FND_MESSAGE.SET_NAME('MSC', 'MSC_CRT_IND_STATUS');
6852: FND_MESSAGE.SET_TOKEN('UNIQUENESS', 'Unique and Nonunique');
6853: FND_MESSAGE.SET_TOKEN('TABLE_NAME', lv_temp_tbl_name);
6854: FND_MESSAGE.SET_TOKEN('STATUS', 'SUCCESS');
6855:
6856: lv_errbuf := FND_MESSAGE.GET;
6857:
6858: ERRBUF := lv_errbuf;

Line 6856: lv_errbuf := FND_MESSAGE.GET;

6852: FND_MESSAGE.SET_TOKEN('UNIQUENESS', 'Unique and Nonunique');
6853: FND_MESSAGE.SET_TOKEN('TABLE_NAME', lv_temp_tbl_name);
6854: FND_MESSAGE.SET_TOKEN('STATUS', 'SUCCESS');
6855:
6856: lv_errbuf := FND_MESSAGE.GET;
6857:
6858: ERRBUF := lv_errbuf;
6859: RETCODE := lv_retcode;
6860: