[Home] [Help]
PACKAGE BODY: APPS.MSC_CL_COLLECTION
Source
1 PACKAGE BODY MSC_CL_COLLECTION AS -- body
2 /* $Header: MSCCLBAB.pls 120.116.12020000.3 2012/10/23 23:32:32 varajgop ship $ */
3
4 -- ========= Global Parameters ===========
5
6 --Instace --
7
8 -- v_process_flag NUMBER:= MSC_UTIL.SYS_NO;
9 -- resource start time
10 v_resource_start_time DATE;
11
12 -- User Environment --
13
14
15
16 -- Collection Program --
17
18 --- PREPLACE CHANGE START ---
19
20
21 --agmcont:
22
23 v_cp_enabled NUMBER;
24 v_recalc_sh NUMBER;
25 v_po_receipts NUMBER;
26 v_monitor_request_id NUMBER;
27 v_req_ext_po_so_linking BOOLEAN;
28
29
30 -- collection status --
31 -- Task Control --
32 v_pipe_task_que VARCHAR2(32);
33 v_pipe_wm VARCHAR2(32);
34 v_pipe_mw VARCHAR2(32);
35 v_pipe_status VARCHAR2(32);
36
37 -- Misc --
38 v_sql_stmt VARCHAR2(32767);
39
40 v_sourcing NUMBER; /* sourcing rule flag */
41
42
43 v_chr9 VARCHAR2(1) := FND_GLOBAL.LOCAL_CHR(9);
44
45 lv_ibuc_coll_start_time DATE; /*IBUC*/
46
47 REGEN_AND_COLLECT CONSTANT NUMBER :=3; --BUG 13724715 (FP of 13907513/12955171)
48
49 SUPPLIES_LOAD_FAIL EXCEPTION;
50
51 /* added this variable to write the debug messages */
52 var_debug number:= 0;
53
54 -- SCE Additions --
55
56
57 -- SRP Additions
58
59
60 -- To collect SRP Data when this profile is set to Yes
61
62
63 -- agmcont
64 -- forward declaration
65 -- v_DSMode NUMBER := MSC_UTIL.SYS_NO;
66
67
68
69 -- =========== Private Functions =============
70
71 FUNCTION alter_temp_table_by_monitor RETURN BOOLEAN
72 IS
73
74 CURSOR c_temp_tbl IS
75 SELECT meaning table_name,
76 attribute1 severity,
77 attribute2 severity_id
78 FROM fnd_lookup_values
79 WHERE lookup_type = 'MSC_TEMP_PARTITIONS' AND
80 enabled_flag = 'Y' AND
81 view_application_id = 700 AND
82 language = userenv('lang');
83
84 lv_req_id NumTblTyp := NumTblTyp();
85 lv_request_id NUMBER;
86 lv_out NUMBER;
87
88 lv_retval boolean;
89 lv_dummy1 varchar2(32);
90 lv_dummy2 varchar2(32);
91 lv_msc_schema varchar2(30);
92 lv_prod_short_name varchar2(30);
93 lv_counter number := 1;
94
95
96 BEGIN
97 FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
98 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'alter_temp_table_by_monitor');
99 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
100
101 lv_prod_short_name := AD_TSPACE_UTIL.get_product_short_name(724);
102 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS,'Product short name - ' || lv_prod_short_name);
103
104 lv_retval := FND_INSTALLATION.GET_APP_INFO (lv_prod_short_name, lv_dummy1, lv_dummy2, lv_msc_schema);
105 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS,'MSC schema - ' || lv_msc_schema);
106
107 FOR c_rec IN c_temp_tbl LOOP
108 IF c_rec.table_name = 'MSC_SALES_ORDERS' AND v_is_so_complete_refresh = FALSE THEN
109 MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1,'sales orders being collected in net change, exch partition not applicable');
110 ELSIF
111 (c_rec.table_name = 'MSC_RESOURCE_REQUIREMENTS' AND
112 (v_apps_ver < MSC_UTIL.G_EAM_CMRO_SUP_VER OR
113 MSC_UTIL.G_CMRO_EAM_INT_ENABLED = 'N')) THEN
114 --changed condition to No to test
115 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS,'For CMRO integration enabled');
116
117 ELSE
118 MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1,'Launching CP to alter table - ' || c_rec.table_name);
119
120 lv_req_id.EXTEND(1);
121 lv_request_id := FND_REQUEST.SUBMIT_REQUEST
122 (lv_msc_schema, -- appln short name
123 'MSCALTBL', -- short name of conc pgm
124 NULL, -- description
125 NULL, -- start date
126 FALSE, -- sub request
127 c_rec.table_name,
128 v_instance_code,
129 c_rec.severity_id
130 );
131
132 COMMIT;
133 IF lv_request_id = 0 THEN
134 FND_MESSAGE.SET_NAME('MSC', 'MSC_ALT_TMP_TABLE_LAUNCH_FAIL');
135 FND_MESSAGE.SET_TOKEN('TABLE_NAME', c_rec.table_name);
136 MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, FND_MESSAGE.GET);
137 RETURN FALSE;
138 ELSE
139 lv_req_id(lv_counter) := lv_request_id;
140 MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1,'Submitted request ' || lv_req_id(lv_counter) || ', to alter table : ' || c_rec.table_name);
141 END IF;
142 lv_counter := lv_counter + 1;
143 END IF;
144
145 END LOOP;
146
147 FOR j IN 1..lv_req_id.COUNT LOOP
148 mrp_cl_refresh_snapshot.wait_for_request(lv_req_id(j), 30, lv_out);
149
150 IF lv_out = 2 THEN
151 FND_MESSAGE.SET_NAME('MSC', 'MSC_ALT_TMP_TABLE_REQ_FAIL');
152 FND_MESSAGE.SET_TOKEN('REQUEST_ID', lv_req_id(j));
153 MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, FND_MESSAGE.GET);
154 RETURN FALSE;
155 ELSE
156 MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1,'Request ' || lv_req_id(j) || ' successful');
157 END IF;
158
159 END LOOP;
160
161 MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1,'end fn alter_temp_table_by_monitor');
162 RETURN TRUE;
163
164 EXCEPTION
165 WHEN OTHERS THEN
166 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, 'Error in altering temp table');
167 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, sqlerrm);
168 RETURN FALSE;
169
170 END alter_temp_table_by_monitor;
171
172 /* REsource Start Time changes
173 Get the refresh date from mrp_ap_apps_instances and
174 update the msc_apps_instances collections_start_time*/
175 PROCEDURE SET_COLLECTIONS_START_TIME(pINSTANCE_ID in number,
176 p_resource_start_time out NOCOPY date)
177 IS
178 lv_sql_stmt varchar2(32767);
179 lv_dblink varchar2(50);
180 lv_resource_start_time DATE := SYSDATE;
181 lv_dest_a2m varchar2(128);
182 lv_instance_code varchar2(10);
183 lv_table_name VARCHAR2(100);
184 lv_res_avail_before_sysdate NUMBER; -- Days
185 lv_collection_start_time DATE;
186 lv_COLL_PULL_START_TIME DATE; --For Bug 6126924
187
188 BEGIN
189 SELECT DECODE(M2A_DBLINK,
190 NULL,MSC_UTIL.NULL_DBLINK,
191 '@'||M2A_DBLINK),
192 DECODE( A2M_DBLINK,
193 NULL,MSC_UTIL.NULL_DBLINK,
194 A2M_DBLINK),
195 INSTANCE_CODE
196 INTO lv_dblink,
197 lv_dest_a2m,
198 lv_instance_code
199 FROM MSC_APPS_INSTANCES
200 WHERE INSTANCE_ID=pINSTANCE_ID;
201
202 IF v_apps_ver >= MSC_UTIL.G_APPS115 THEN
203 lv_table_name := 'MRP_AP_APPS_INSTANCES_ALL';
204 ELSE
205 lv_table_name := 'MRP_AP_APPS_INSTANCES';
206 END IF;
207
208 lv_res_avail_before_sysdate := nvl(TO_NUMBER(FND_PROFILE.VAlUE('MSC_RES_AVAIL_BEFORE_SYSDAT')),1);
209
210 IF v_instance_type <> MSC_UTIL.G_INS_OTHER THEN
211 lv_sql_stmt:= 'SELECT nvl(mar.LRD,systimestamp) , nvl(mar.LRD,sysdate)- '||lv_res_avail_before_sysdate
212 ||' FROM '||lv_table_name||lv_dblink||' mar'
213 ||' WHERE INSTANCE_ID = '||pINSTANCE_ID
214 ||' AND INSTANCE_CODE = '''||lv_instance_code||''''
215 ||' AND nvl(A2M_DBLINK,'''||MSC_UTIL.NULL_DBLINK||''') = '''||lv_dest_a2m||'''' ;
216
217 EXECUTE IMMEDIATE lv_sql_stmt INTO lv_ibuc_coll_start_time, lv_resource_start_time;
218
219
220 SELECT nvl(COLLECTIONS_START_TIME,sysdate)
221 INTO lv_collection_start_time
222 FROM msc_coll_parameters
223 where instance_id = pINSTANCE_ID;
224 /* For Bug 6141966 */
225 MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, ' last asl refresh time is '|| lv_collection_start_time); --ASL
226 END IF;
227
228 IF v_instance_type = MSC_UTIL.G_INS_OTHER THEN
229 lv_resource_start_time := lv_resource_start_time - nvl(lv_res_avail_before_sysdate,1);
230 lv_collection_start_time:= SYSDATE;
231 END IF;
232
233 UPDATE MSC_APPS_INSTANCES
234 SET COLLECTIONS_START_TIME= lv_collection_start_time
235 where instance_id = pINSTANCE_ID;
236 /*ASL */
237
238 IF ((v_coll_prec.app_supp_cap_flag=MSC_UTIL.SYS_YES or v_coll_prec.app_supp_cap_flag=MSC_UTIL.ASL_YES_RETAIN_CP) AND NOT v_is_legacy_refresh) THEN
239 lv_sql_stmt := 'UPDATE MSC_INSTANCE_ORGS '
240 ||' SET last_succ_asl_ref_time = :lv_collection_start_time'
241 ||' WHERE sr_instance_id = ' || pINSTANCE_ID
242 || ' AND ORGANIZATION_ID ' || MSC_UTIL.v_in_org_str ;
243
244 MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'sql statement is ' || lv_sql_stmt);
245 EXECUTE IMMEDIATE lv_sql_stmt USING lv_collection_start_time;
246 END IF ;
247
248 /*IRO Bug 6126698*/
249
250 IF ((v_coll_prec.internal_repair_flag=MSC_UTIL.SYS_YES ) AND NOT v_is_legacy_refresh) THEN
251 lv_sql_stmt := 'UPDATE MSC_INSTANCE_ORGS '
252 ||' SET LAST_SUCC_IRO_REF_TIME = :lv_collection_start_time'
253 ||' WHERE sr_instance_id = ' || pINSTANCE_ID
254 || ' AND ORGANIZATION_ID ' || MSC_UTIL.v_depot_org_str ;
255
256 MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'sql statement is ' || lv_sql_stmt);
257 EXECUTE IMMEDIATE lv_sql_stmt USING lv_collection_start_time;
258 END IF ;
259
260 /* Res Bug 6144734 */
261 IF ((v_coll_prec.reserves_flag = MSC_UTIL.SYS_YES ) AND NOT v_is_legacy_refresh) THEN
262 lv_sql_stmt := 'UPDATE MSC_INSTANCE_ORGS '
263 ||' SET LAST_SUCC_RES_REF_TIME = :lv_collection_start_time'
264 ||' WHERE sr_instance_id = ' || pINSTANCE_ID
265 || ' AND ORGANIZATION_ID ' || MSC_UTIL.v_in_org_str ;
266
267 MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'sql statement is ' || lv_sql_stmt);
268 EXECUTE IMMEDIATE lv_sql_stmt USING lv_collection_start_time;
269 END IF ;
270
271 MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'Item Flag ' || v_coll_prec.Item_flag);
272 IF (v_coll_prec.Item_flag=MSC_UTIL.SYS_YES AND NOT v_is_legacy_refresh) THEN
273 lv_sql_stmt := 'UPDATE MSC_INSTANCE_ORGS '
274 ||' SET LAST_SUCC_ITEM_REF_TIME = :lv_collection_start_time'
275 ||' WHERE sr_instance_id = ' || pINSTANCE_ID
276 || ' AND ORGANIZATION_ID ' || MSC_UTIL.v_in_org_str ;
277 MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'sql statement is ' || lv_sql_stmt);
278 EXECUTE IMMEDIATE lv_sql_stmt USING lv_collection_start_time;
279 END IF ;
280
281 --============= For Bug 6126924
282
283 SELECT PULL_WRKR_START_TIME into lv_COLL_PULL_START_TIME
284 from msc_coll_parameters
285 where INSTANCE_ID = pINSTANCE_ID;
286
287 UPDATE msc_apps_instances
288 SET PULL_WRKR_START_TIME = lv_COLL_PULL_START_TIME,
289 SNAP_REF_START_TIME = lv_collection_start_time
290 where instance_id = pINSTANCE_ID;
291
292 --=============
293
294 /*ASL */
295
296 p_resource_start_time := lv_resource_start_time;
297 commit;
298
299 EXCEPTION
300 WHEN OTHERS THEN
301 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, SQLERRM);
302 END SET_COLLECTIONS_START_TIME;
303
304
305
306 /* removed LINK_SUPP_SO_DEMAND_EXT for bug5952569 and placed in
307 package MSC_CL_DEMAND_ODS_LOAD */
308 -- ******************************
309
310 /* removed LINK_SUPP_SO_DEMAND_110 for bug5952569 and placed in
311 package MSC_CL_DEMAND_ODS_LOAD */
312
313 /* removed LINK_SUPP_SO_DEMAND_11I2 for bug5952569 and placed in
314 package MSC_CL_DEMAND_ODS_LOAD */
315
316
317
318 FUNCTION PURGE_STAGING (pINSTANCE_ID in number)
319 RETURN boolean
320 IS
321 lvs_request_id number;
322
323 l_call_status boolean;
324
325 l_phase varchar2(80);
326 l_status varchar2(80);
327 l_dev_phase varchar2(80);
328 l_dev_status varchar2(80);
329 l_message varchar2(2048);
330 BEGIN
331
332 lvs_request_id := FND_REQUEST.SUBMIT_REQUEST(
333 'MSC',
334 'MSCPDCP',
335 NULL, -- description
336 NULL, -- start date
337 FALSE, -- not a sub request,
338 pINSTANCE_ID,
339 MSC_UTIL.SYS_YES); -- validation=sys_yes
340
341 COMMIT;
342
343 IF lvs_request_id=0 THEN
344 FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_LAUNCH_PURGER_FAIL');
345 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
346 RETURN FALSE;
347 ELSE
348 FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_PURGER_REQUEST_ID');
349 FND_MESSAGE.SET_TOKEN('REQUEST_ID', lvs_request_id);
350 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
351 END IF;
352
353 LOOP
354 /* come out of function only when the MSCPDCP is complete - reqd for Collections incompatibility */
355
356 l_call_status:= FND_CONCURRENT.GET_REQUEST_STATUS
357 ( lvs_request_id,
358 NULL,
359 NULL,
360 l_phase,
361 l_status,
362 l_dev_phase,
363 l_dev_status,
364 l_message);
365
366 IF (l_call_status=FALSE) THEN
367 FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_LAUNCH_PURGER_FAIL');
368 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
369
370 FND_MESSAGE.SET_NAME('MSC', 'MSC_FUNC_MON_RUNNING');
371 FND_MESSAGE.SET_TOKEN('REQUEST_ID',lvs_request_id);
372 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
373
374 FND_MESSAGE.SET_NAME('MSC', 'MSC_CL_CONC_MESSAGE');
375 FND_MESSAGE.SET_TOKEN('MESSAGE',l_message);
376 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
377
378 RETURN FALSE;
379 END IF;
380
381 EXIT WHEN l_dev_phase = 'COMPLETE';
382
383 END LOOP;
384
385 RETURN TRUE;
386
387 EXCEPTION
388 WHEN OTHERS THEN
389 FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_LAUNCH_PURGER_FAIL');
390 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
391 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, SQLERRM);
392 RETURN FALSE;
393 END PURGE_STAGING;
394
395
396 /* procedure IS_SUPPLIES_LOAD_DONE has been moved to package MSC_CL_SUPPLY_ODS_LOAD
397 through bug5952569 */
398
399 /* procedure LINK_SUPPLY_TOP_LINK_IDhas been moved to package MSC_CL_SETUP_ODS_LOAD
400 through bug5952569 */
401
402 /* ds change chaneg end */
403
404 /* procedure create_supplies_tmp_ind has been moved to package MSC_CL_SUPPLY_ODS_LOAD
405 through bug5952569 */
406 /* procedure drop_supplies_tmp_ind has been moved to package MSC_CL_SUPPLY_ODS_LOAD
407 through bug5952569 */
408
409 /* function drop_demands_tmp_ind has been moved to package MSC_CL_DEMAND_ODS_LOAD
410 (bug5952569) */
411
412 /* function drop_sales_orders_tmp_ind has been moved to package MSC_CL_DEMAND_ODS_LOAD
413 (bug5952569) */
414
415 --****************************
416 PROCEDURE LOG_MESSAGE(pSOURCE IN NUMBER,
417 pID IN NUMBER,
418 pCREATION_DATE IN DATE,
419 pMTYPE IN NUMBER,
420 pERRBUF IN VARCHAR2)
421 IS
422 SEQ NUMBER;
423 BEGIN
424
425 SELECT MSC_ERRORS_S.NEXTVAL
426 INTO SEQ
427 FROM DUAL;
428
429 IF fnd_global.conc_request_id > 0 THEN
430
431 FND_FILE.PUT_LINE( FND_FILE.LOG,
432 TO_CHAR(SEQ)||':'
433 ||TO_CHAR(pID)||':'
434 ||TO_CHAR(pMTYPE)||':'
435 ||pERRBUF );
436 null;
437
438 END IF;
439 EXCEPTION
440 WHEN OTHERS THEN
441 RETURN;
442 END LOG_MESSAGE;
443
444
445 PROCEDURE LOG_MESSAGE(pSOURCE IN NUMBER,
446 pID IN NUMBER,
447 pCREATION_DATE IN DATE,
448 pMTYPE IN NUMBER,
449 pPROCEDURE_NAME IN VARCHAR2,
450 pEXCEPTION_TYPE IN VARCHAR2 := NULL,
451 pSEGMENT1 IN VARCHAR2 := NULL,
452 pSEGMENT2 IN VARCHAR2 := NULL,
453 pSEGMENT3 IN VARCHAR2 := NULL,
454 pSEGMENT4 IN VARCHAR2 := NULL,
455 pSEGMENT5 IN VARCHAR2 := NULL,
456 pSEGMENT6 IN VARCHAR2 := NULL,
457 pSEGMENT7 IN VARCHAR2 := NULL,
458 pSEGMENT8 IN VARCHAR2 := NULL,
459 pSEGMENT9 IN VARCHAR2 := NULL,
460 pSEGMENT10 IN VARCHAR2 := NULL)
461 IS
462 SEQ NUMBER;
463 BEGIN
464
465 SELECT MSC_ERRORS_S.NEXTVAL
466 INTO SEQ
467 FROM DUAL;
468
469 IF fnd_global.conc_request_id > 0 THEN
470
471 FND_FILE.PUT_LINE( FND_FILE.LOG,
472 TO_CHAR(SEQ)||':'
473 ||TO_CHAR(pID)||':'
474 ||TO_CHAR(pMTYPE)||':'
475 ||pPROCEDURE_NAME||':'
476 ||pEXCEPTION_TYPE||':'
477 ||pSEGMENT1||':'
478 ||pSEGMENT2||':'
479 ||pSEGMENT3||':'
480 ||pSEGMENT4||':'
481 ||pSEGMENT5||':'
482 ||pSEGMENT6||':'
483 ||pSEGMENT7||':'
484 ||pSEGMENT8||':'
485 ||pSEGMENT9||':'
486 ||pSEGMENT10||':');
487 null;
488 END IF;
489 EXCEPTION
490 WHEN OTHERS THEN
491 RETURN;
492 END LOG_MESSAGE;
493
494
495
496 FUNCTION is_monitor_status_running RETURN NUMBER
497 IS
498 l_call_status boolean;
499 l_phase varchar2(80);
500 l_status varchar2(80);
501 l_dev_phase varchar2(80);
502 l_dev_status varchar2(80);
503 l_message varchar2(2048);
504
505 BEGIN
506
507 IF v_cp_enabled= MSC_UTIL.SYS_NO THEN
508 RETURN MSC_UTIL.SYS_YES;
509 END IF;
510
511 l_call_status:= FND_CONCURRENT.GET_REQUEST_STATUS
512 ( v_monitor_request_id,
513 NULL,
514 NULL,
515 l_phase,
516 l_status,
517 l_dev_phase,
518 l_dev_status,
519 l_message);
520
521 IF l_call_status=FALSE THEN
522 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, 'IS_MONITOR_STATUS_RUNNING');
523
524 FND_MESSAGE.SET_NAME('MSC', 'MSC_FUNC_MON_RUNNING');
525 FND_MESSAGE.SET_TOKEN('REQUEST_ID',v_monitor_request_id);
526 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
527
528 FND_MESSAGE.SET_NAME('MSC', 'MSC_CL_CONC_MESSAGE');
529 FND_MESSAGE.SET_TOKEN('MESSAGE',l_message);
530 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
531
532 RETURN MSC_UTIL.SYS_NO;
533 END IF;
534
535 IF l_dev_phase='RUNNING' THEN
536 RETURN MSC_UTIL.SYS_YES;
537 ELSE
538 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, 'IS_MONITOR_STATUS_RUNNING');
539
540 FND_MESSAGE.SET_NAME('MSC', 'MSC_FUNC_MON_RUN');
541 FND_MESSAGE.SET_TOKEN('REQUEST_ID', v_monitor_request_id);
542 FND_MESSAGE.SET_TOKEN('PHASE',l_dev_phase);
543 FND_MESSAGE.SET_TOKEN('STATUS',l_dev_status);
544 --MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
545
546 FND_MESSAGE.SET_NAME('MSC', 'MSC_CL_CONC_MESSAGE');
547 FND_MESSAGE.SET_TOKEN('MESSAGE',l_message);
548 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
549
550 RETURN MSC_UTIL.SYS_NO;
551 END IF;
552
553 END is_monitor_status_running;
554
555 FUNCTION is_request_status_running RETURN NUMBER
556 IS
557 l_call_status boolean;
558 l_phase varchar2(80);
559 l_status varchar2(80);
560 l_dev_phase varchar2(80);
561 l_dev_status varchar2(80);
562 l_message varchar2(2048);
563
564 l_request_id NUMBER;
565
566 BEGIN
567
568 IF v_cp_enabled= MSC_UTIL.SYS_NO THEN
569 RETURN MSC_UTIL.SYS_YES;
570 END IF;
571
572 l_request_id := FND_GLOBAL.CONC_REQUEST_ID;
573
574 l_call_status:= FND_CONCURRENT.GET_REQUEST_STATUS
575 ( l_request_id,
576 NULL,
577 NULL,
578 l_phase,
579 l_status,
580 l_dev_phase,
581 l_dev_status,
582 l_message);
583
584 IF l_call_status=FALSE THEN
585 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, 'IS_REQUEST_STATUS_RUNNING');
586
587 FND_MESSAGE.SET_NAME('MSC', 'MSC_FUNC_MON_RUNNING');
588 FND_MESSAGE.SET_TOKEN('REQUEST_ID',l_request_id);
589 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
590
591 FND_MESSAGE.SET_NAME('MSC', 'MSC_CL_CONC_MESSAGE');
592 FND_MESSAGE.SET_TOKEN('MESSAGE',l_message);
593 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
594
595 RETURN MSC_UTIL.SYS_NO;
596 END IF;
597
598 IF l_dev_phase='RUNNING' THEN
599 RETURN MSC_UTIL.SYS_YES;
600 ELSE
601 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, 'IS_REQUEST_STATUS_RUNNING');
602
603 FND_MESSAGE.SET_NAME('MSC', 'MSC_FUNC_MON_RUN');
604 FND_MESSAGE.SET_TOKEN('REQUEST_ID',l_request_id);
605 FND_MESSAGE.SET_TOKEN('PHASE',l_dev_phase);
606 FND_MESSAGE.SET_TOKEN('STATUS',l_dev_status);
607 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
608
609 FND_MESSAGE.SET_NAME('MSC', 'MSC_CL_CONC_MESSAGE');
610 FND_MESSAGE.SET_TOKEN('MESSAGE',l_message);
611 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
612
613 RETURN MSC_UTIL.SYS_NO;
614 END IF;
615
616 END is_request_status_running;
617
618 FUNCTION is_worker_status_valid( ps_request_id IN NumTblTyp)
619 RETURN NUMBER
620 IS
621 l_call_status boolean;
622 l_phase varchar2(80);
623 l_status varchar2(80);
624 l_dev_phase varchar2(80);
625 l_dev_status varchar2(80);
626 l_message varchar2(2048);
627
628 l_request_id NUMBER;
629 BEGIN
630
631 IF v_cp_enabled= MSC_UTIL.SYS_NO THEN
632 RETURN MSC_UTIL.SYS_YES;
633 END IF;
634
635 FOR lc_i IN 1..(ps_request_id.COUNT-1) LOOP
636
637 l_request_id := ps_request_id(lc_i);
638
639 l_call_status:= FND_CONCURRENT.GET_REQUEST_STATUS
640 ( l_request_id,
641 NULL,
642 NULL,
643 l_phase,
644 l_status,
645 l_dev_phase,
646 l_dev_status,
647 l_message);
648
649 IF l_call_status=FALSE THEN
650 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, 'IS_WORKER_STATUS_VALID');
651
652 FND_MESSAGE.SET_NAME('MSC', 'MSC_FUNC_MON_RUNNING');
653 FND_MESSAGE.SET_TOKEN('REQUEST_ID',l_request_id);
654 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
655
656 FND_MESSAGE.SET_NAME('MSC', 'MSC_CL_CONC_MESSAGE');
657 FND_MESSAGE.SET_TOKEN('MESSAGE',l_message);
658 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
659
660 RETURN MSC_UTIL.SYS_NO;
661 END IF;
662
663 IF l_dev_phase NOT IN ( 'PENDING','RUNNING') THEN
664 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, 'IS_WORKER_STATUS_VALID');
665
666 FND_MESSAGE.SET_NAME('MSC', 'MSC_FUNC_MON_RUN');
667 FND_MESSAGE.SET_TOKEN('REQUEST_ID',l_request_id);
668 FND_MESSAGE.SET_TOKEN('PHASE',l_dev_phase);
669 FND_MESSAGE.SET_TOKEN('STATUS',l_dev_status);
670 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
671
672 FND_MESSAGE.SET_NAME('MSC', 'MSC_CL_CONC_MESSAGE');
673 FND_MESSAGE.SET_TOKEN('MESSAGE',l_message);
674 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
675
676 RETURN MSC_UTIL.SYS_NO;
677 END IF;
678
679 END LOOP;
680
681 RETURN MSC_UTIL.SYS_YES;
682
683 END is_worker_status_valid;
684
685 FUNCTION all_workers_completed( ps_request_id IN NumTblTyp)
686 RETURN NUMBER
687 IS
688 l_call_status boolean;
689 l_phase varchar2(80);
690 l_status varchar2(80);
691 l_dev_phase varchar2(80);
692 l_dev_status varchar2(80);
693 l_message varchar2(1024);
694
695 l_request_id NUMBER;
696
697 req_complete number := 0;
698 total_req number;
699 BEGIN
700 req_complete := 0;
701 total_req := 0;
702
703 IF v_cp_enabled= MSC_UTIL.SYS_NO THEN
704 RETURN MSC_UTIL.SYS_YES;
705 END IF;
706
707 total_req := ps_request_id.COUNT - 1;
708 MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'Total requests = :' ||total_req);
709
710 FOR lc_i IN 1..(ps_request_id.COUNT-1) LOOP
711
712 l_request_id := ps_request_id(lc_i);
713
714 l_call_status:= FND_CONCURRENT.GET_REQUEST_STATUS
715 ( l_request_id,
716 NULL,
717 NULL,
718 l_phase,
719 l_status,
720 l_dev_phase,
721 l_dev_status,
722 l_message);
723 MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'Request id = '||l_request_id);
724
725 IF l_dev_phase IN ('COMPLETE') THEN
726
727 req_complete := req_complete + 1;
728
729 MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'ALL_WORKERS_COMPLETED');
730
731 FND_MESSAGE.SET_NAME('MSC', 'MSC_FUNC_MON_RUN');
732 FND_MESSAGE.SET_TOKEN('REQUEST_ID',l_request_id);
733 FND_MESSAGE.SET_TOKEN('PHASE',l_dev_phase);
734 FND_MESSAGE.SET_TOKEN('STATUS',l_dev_status);
735 MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, FND_MESSAGE.GET);
736
737 FND_MESSAGE.SET_NAME('MSC', 'MSC_CL_TOTAL_REQS_COMPLETE');
738 FND_MESSAGE.SET_TOKEN('REQUESTS',req_complete);
739 MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, FND_MESSAGE.GET);
740
741 END IF;
742
743 END LOOP;
744
745 IF total_req = req_complete THEN
746 FND_MESSAGE.SET_NAME('MSC', 'MSC_CL_ALL_WORKERS_COMP');
747 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
748 RETURN MSC_UTIL.SYS_YES;
749 ELSE
750 RETURN MSC_UTIL.SYS_NO;
751 END IF;
752
753 END all_workers_completed;
754
755 FUNCTION is_msctbl_partitioned ( p_table_name IN VARCHAR2)
756 RETURN BOOLEAN
757 IS
758
759 lv_partitioned VARCHAR2(3);
760
761 CURSOR c_partitioned IS
762 SELECT tab.partitioned
763 FROM ALL_TABLES tab,
764 FND_ORACLE_USERID a,
765 FND_PRODUCT_INSTALLATIONS b
766 WHERE a.oracle_id = b.oracle_id
767 AND b.application_id= 724
768 AND tab.owner= a.oracle_username
769 AND tab.table_name= p_table_name;
770
771 BEGIN
772
773 OPEN c_partitioned;
774 FETCH c_partitioned INTO lv_partitioned;
775 CLOSE c_partitioned;
776
777 IF lv_partitioned='YES' THEN RETURN TRUE; END IF;
778 RETURN FALSE;
779 EXCEPTION
780 WHEN OTHERS THEN
781 RETURN FALSE;
782 END is_msctbl_partitioned;
783
784 /* function LINK_PARENT_SALES_ORDERS has been moved to package MSC_CL_DEMAND_ODS_LOAD
785 through bug5952569 */
786
787 /* function LINK_PARENT_SALES_ORDERS_MDS has been moved to package MSC_CL_DEMAND_ODS_LOAD
788 through bug5952569 */
789
790
791
792 /* procedure CLEANSE_DATA been moved to package MSC_CL_SETUP_ODS_LOAD
793 through bug5952569 */
794
795 PROCEDURE TRUNCATE_MSC_TABLE( p_table_name IN VARCHAR2) IS
796
797 lv_sql_stmt VARCHAR2(2048);
798
799 lv_task_start_time DATE;
800 lv_retval boolean;
801 lv_dummy1 varchar2(32);
802 lv_dummy2 varchar2(32);
803 lv_msc_schema varchar2(32);
804
805 BEGIN
806
807 lv_task_start_time:= SYSDATE;
808
809 lv_retval := FND_INSTALLATION.GET_APP_INFO (
810 'MSC', lv_dummy1, lv_dummy2, lv_msc_schema);
811
812 FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
813 FND_MESSAGE.SET_TOKEN('PROCEDURE',
814 'TRUNCATE_MSC_TABLE:'||lv_msc_schema||'.'||p_table_name);
815 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, ' '||FND_MESSAGE.GET);
816
817 lv_sql_stmt:= 'TRUNCATE TABLE '||lv_msc_schema||'.'||p_table_name;
818
819 EXECUTE IMMEDIATE lv_sql_stmt;
820 COMMIT;
821
822 /*
823 AD_DDL.DO_DDL( APPLSYS_SCHEMA => lv_msc_schema,
824 APPLICATION_SHORT_NAME => 'MSC',
825 STATEMENT_TYPE => AD_DDL.TRUNCATE_TABLE,
826 STATEMENT => lv_sql_stmt,
827 OBJECT_NAME => p_table_name);
828 */
829
830
831 FND_MESSAGE.SET_NAME('MSC', 'MSC_ELAPSED_TIME');
832 FND_MESSAGE.SET_TOKEN('ELAPSED_TIME',
833 TO_CHAR(CEIL((SYSDATE- lv_task_start_time)*14400.0)/10));
834 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, ' '||FND_MESSAGE.GET);
835
836 msc_util.print_top_wait(CEIL((SYSDATE- lv_task_start_time)*14400.0)/10);
837 msc_util.print_cum_stat(CEIL((SYSDATE- lv_task_start_time)*14400.0)/10);
838 msc_util.print_bad_sqls(CEIL((SYSDATE- lv_task_start_time)*14400.0)/10);
839 END TRUNCATE_MSC_TABLE;
840
841
842
843 PROCEDURE INITIALIZE_LOAD_GLOBALS( pINSTANCE_ID IN NUMBER)
844 IS
845 lv_last_refresh_type VARCHAR2(1);
846 lv_so_last_refresh_type VARCHAR2(1);
847 lv_retval BOOLEAN;
848 lv_dummy1 VARCHAR2(32);
849 lv_dummy2 VARCHAR2(32);
850 BEGIN
851
852 SELECT LRTYPE,
853 SO_LRTYPE,
854 APPS_VER,
855 SYSDATE,
856 SYSDATE,
857 FND_GLOBAL.USER_ID,
858 SYSDATE,
859 FND_GLOBAL.USER_ID,
860 UPPER(INSTANCE_CODE), /* Bug 2129155 */
861 INSTANCE_TYPE, -- OPM
862 LR_SOURCING_FLAG -- Sourcing Flag
863 INTO lv_last_refresh_type,
864 lv_so_last_refresh_type,
865 v_apps_ver,
866 START_TIME,
867 v_current_date,
868 v_current_user,
869 v_current_date,
870 v_current_user,
871 v_instance_code,
872 v_instance_type, -- OPM
873 v_sourcing_flag -- Sourcing Flag
874 FROM MSC_APPS_INSTANCES
875 WHERE INSTANCE_ID= pINSTANCE_ID;
876
877 --- PREPLACE CHANGE START ---
878 /*
879 IF lv_last_refresh_type= 'C' THEN
880 v_is_complete_refresh := TRUE;
881 v_is_incremental_refresh := FALSE;
882 ELSE
883 v_is_complete_refresh := FALSE;
884 v_is_incremental_refresh := TRUE;
885 END IF;
886 */
887
888 --agmcont:
889 v_is_cont_refresh := FALSE;
890 IF lv_last_refresh_type = 'C' THEN
891 v_is_complete_refresh := TRUE;
892 v_is_incremental_refresh := FALSE;
893 v_is_partial_refresh := FALSE;
894 ELSIF lv_last_refresh_type = 'I' THEN
895 v_is_complete_refresh := FALSE;
896 v_is_incremental_refresh := TRUE;
897 v_is_partial_refresh := FALSE;
898 ELSIF lv_last_refresh_type = 'P' THEN
899 v_is_complete_refresh := FALSE;
900 v_is_incremental_refresh := FALSE;
901 v_is_partial_refresh := TRUE;
902 ELSIF lv_last_refresh_type = 'L' THEN -- legacy change for L -flow
903 v_is_complete_refresh := FALSE;
904 v_is_incremental_refresh := TRUE; -- we will piggy ride on incremetal for legacy
905 v_is_partial_refresh := FALSE;
906 v_is_legacy_refresh := TRUE;
907 ELSIF lv_last_refresh_type = 'T' THEN
908 v_is_complete_refresh := FALSE;
909 v_is_incremental_refresh := FALSE;
910 v_is_partial_refresh := FALSE;
911 v_is_cont_refresh := TRUE;
912 END IF;
913 --- PREPLACE CHANGE END ---
914
915 --agmcont:
916 -- so refresh flags for continuous refresh
917 -- are set in launch_mon_partial and launch worker
918
919 IF lv_so_last_refresh_type= 'C' THEN
920 v_is_so_complete_refresh := TRUE;
921 v_is_so_incremental_refresh := FALSE;
922 ELSE
923 v_is_so_complete_refresh := FALSE;
924 v_is_so_incremental_refresh := TRUE;
925 END IF;
926
927
928 v_pipe_task_que := 'MSC_CL_TQ'||TO_CHAR(pINSTANCE_ID);
929 v_pipe_wm := 'MSC_CL_WM'||TO_CHAR(pINSTANCE_ID);
930 v_pipe_mw := 'MSC_CL_MW'||TO_CHAR(pINSTANCE_ID);
931 v_pipe_status := 'MSC_CL_ST'||TO_CHAR(pINSTANCE_ID);
932
933 v_instance_id := pINSTANCE_ID;
934 PBS := TO_NUMBER( FND_PROFILE.VALUE('MRP_PURGE_BATCH_SIZE'));
935 ---------------- Set Flags -----------------------------
936 -- set the flags as to whether discrete and/or process
937 -- manufacturing are being used in the same instance
938
939 v_discrete_flag := MSC_UTIL.SYS_NO;
940 v_process_flag := MSC_UTIL.SYS_NO;
941 /************** LEGACY_CHANGE_START*************************/
942
943 IF v_instance_type = MSC_UTIL.G_INS_DISCRETE OR
944 v_instance_type = MSC_UTIL.G_INS_OTHER OR
945 v_instance_type = MSC_UTIL.G_INS_MIXED THEN
946 v_discrete_flag := MSC_UTIL.SYS_YES;
947 END IF;
948
949 IF v_instance_type = MSC_UTIL.G_INS_PROCESS OR
950 v_instance_type = MSC_UTIL.G_INS_MIXED THEN
951 v_process_flag := MSC_UTIL.SYS_YES;
952 END IF;
953 /*****************LEGACY_CHANGE_ENDS************************/
954
955 lv_retval := FND_INSTALLATION.GET_APP_INFO(
956 'FND', lv_dummy1,lv_dummy2, v_applsys_schema);
957
958
959 END INITIALIZE_LOAD_GLOBALS;
960
961
962 /* procedure TRANSFORM_KEYS has been moved to package MSC_CL_SETUP_ODS_LOAD
963 through bug5952569 */
964
965 FUNCTION SET_ST_STATUS( ERRBUF OUT NOCOPY VARCHAR2,
966 RETCODE OUT NOCOPY NUMBER,
967 pINSTANCE_ID IN NUMBER,
968 pST_STATUS IN NUMBER)
969 RETURN BOOLEAN
970 IS
971
972 lv_staging_table_status NUMBER;
973
974 BEGIN
975
976
977 ---=================== COLLECTING ===========================
978 IF pST_STATUS= MSC_UTIL.G_ST_COLLECTING THEN
979 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS,'pST_STATUS = MSC_UTIL.G_ST_COLLECTING');
980 SELECT mai.ST_STATUS
981 INTO lv_staging_table_status
982 FROM MSC_APPS_INSTANCES mai
983 WHERE mai.INSTANCE_ID= pINSTANCE_ID
984 FOR UPDATE;
985
986 IF lv_staging_table_status= MSC_UTIL.G_ST_EMPTY THEN
987 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS,'lv_staging_table_status = MSC_UTIL.G_ST_EMPTY');
988 FND_MESSAGE.SET_NAME('MSC', 'MSC_ST_ERROR_NO_DATA');
989 ERRBUF:= FND_MESSAGE.GET;
990
991 RETCODE := MSC_UTIL.G_WARNING;
992 RETURN FALSE;
993
994 ELSIF lv_staging_table_status= MSC_UTIL.G_ST_PULLING THEN
995 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS,'lv_staging_table_status = MSC_UTIL.G_ST_PULLING');
996 FND_MESSAGE.SET_NAME('MSC', 'MSC_ST_ERROR_PULLING');
997 ERRBUF:= FND_MESSAGE.GET;
998
999 RETCODE := MSC_UTIL.G_ERROR;
1000 RETURN FALSE;
1001
1002 ELSIF lv_staging_table_status= MSC_UTIL.G_ST_COLLECTING THEN
1003 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS,'lv_staging_table_status = MSC_UTIL.G_ST_COLLECTING');
1004 FND_MESSAGE.SET_NAME('MSC', 'MSC_ST_ERROR_LOADING');
1005 ERRBUF:= FND_MESSAGE.GET;
1006
1007 RETCODE := MSC_UTIL.G_ERROR;
1008 RETURN FALSE;
1009
1010 ELSIF lv_staging_table_status= MSC_UTIL.G_ST_PURGING THEN
1011 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS,'lv_staging_table_status = MSC_UTIL.G_ST_PURGING');
1012 FND_MESSAGE.SET_NAME('MSC', 'MSC_ST_ERROR_PURGING');
1013 ERRBUF:= FND_MESSAGE.GET;
1014
1015 RETCODE := MSC_UTIL.G_ERROR;
1016 RETURN FALSE;
1017
1018 ELSE
1019 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS,' st status is success');
1020 RETCODE := MSC_UTIL.G_SUCCESS ;
1021
1022 UPDATE MSC_APPS_INSTANCES
1023 SET ST_STATUS= MSC_UTIL.G_ST_COLLECTING,
1024 LCID= MSC_COLLECTION_S.NEXTVAL,
1025 LAST_UPDATE_DATE= v_current_date,
1026 LAST_UPDATED_BY= v_current_user,
1027 REQUEST_ID= FND_GLOBAL.CONC_REQUEST_ID
1028 WHERE INSTANCE_ID= pINSTANCE_ID;
1029
1030 SELECT MSC_COLLECTION_S.CURRVAL
1031 INTO v_last_collection_id
1032 FROM DUAL;
1033
1034 RETURN TRUE;
1035
1036 END IF;
1037
1038 ---===================== PURGING ===================
1039 ELSIF pST_STATUS= MSC_UTIL.G_ST_PURGING THEN
1040
1041 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS,' pST_STATUS= MSC_UTIL.G_ST_PURGING ');
1042 SELECT mai.ST_STATUS
1043 INTO lv_staging_table_status
1044 FROM MSC_APPS_INSTANCES mai
1045 WHERE mai.INSTANCE_ID= pINSTANCE_ID
1046 FOR UPDATE;
1047
1048 IF lv_staging_table_status= MSC_UTIL.G_ST_EMPTY THEN
1049 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS,' lv_staging_table_status= MSC_UTIL.G_ST_EMPTY ');
1050 FND_MESSAGE.SET_NAME('MSC', 'MSC_ST_ERROR_NO_DATA');
1051 ERRBUF:= FND_MESSAGE.GET;
1052
1053 RETCODE := MSC_UTIL.G_WARNING;
1054 RETURN FALSE;
1055
1056 ELSIF lv_staging_table_status= MSC_UTIL.G_ST_PULLING THEN
1057 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS,' lv_staging_table_status= MSC_UTIL.G_ST_PULLING ');
1058 FND_MESSAGE.SET_NAME('MSC', 'MSC_ST_ERROR_PULLING');
1059 ERRBUF:= FND_MESSAGE.GET;
1060
1061 RETCODE := MSC_UTIL.G_ERROR;
1062 RETURN FALSE;
1063
1064 ELSIF lv_staging_table_status= MSC_UTIL.G_ST_COLLECTING THEN
1065 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS,' lv_staging_table_status= MSC_UTIL.G_ST_COLLECTING ');
1066 FND_MESSAGE.SET_NAME('MSC', 'MSC_ST_ERROR_DATA_EXIST');
1067 ERRBUF:= FND_MESSAGE.GET;
1068
1069 RETCODE := MSC_UTIL.G_ERROR;
1070 RETURN FALSE;
1071
1072 ELSIF lv_staging_table_status= MSC_UTIL.G_ST_PURGING THEN
1073 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS,' lv_staging_table_status= MSC_UTIL.G_ST_PURGING ');
1074 FND_MESSAGE.SET_NAME('MSC', 'MSC_ST_ERROR_PURGING');
1075 ERRBUF:= FND_MESSAGE.GET;
1076
1077 RETCODE := MSC_UTIL.G_ERROR;
1078 RETURN FALSE;
1079
1080 ELSE
1081 RETCODE := MSC_UTIL.G_SUCCESS ;
1082 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS,' stsetup = success');
1083 UPDATE MSC_APPS_INSTANCES
1084 SET ST_STATUS= MSC_UTIL.G_ST_PURGING,
1085 SO_TBL_STATUS= MSC_UTIL.SYS_YES,
1086 LAST_UPDATE_DATE= v_current_date,
1087 LAST_UPDATED_BY= v_current_user,
1088 REQUEST_ID= FND_GLOBAL.CONC_REQUEST_ID
1089 WHERE INSTANCE_ID= pINSTANCE_ID;
1090
1091 RETURN TRUE;
1092
1093 END IF;
1094
1095 ---===================== EMPTY ====================
1096 ELSIF pST_STATUS= MSC_UTIL.G_ST_EMPTY THEN
1097 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS,' pST_STATUS= MSC_UTIL.G_ST_EMPTY');
1098 UPDATE MSC_APPS_INSTANCES
1099 SET ST_STATUS= MSC_UTIL.G_ST_EMPTY,
1100 SO_TBL_STATUS= MSC_UTIL.SYS_YES,
1101 LAST_UPDATE_DATE= v_current_date,
1102 LAST_UPDATED_BY= v_current_user,
1103 REQUEST_ID= FND_GLOBAL.CONC_REQUEST_ID
1104 WHERE INSTANCE_ID= pINSTANCE_ID;
1105
1106 RETCODE:= MSC_UTIL.G_SUCCESS ;
1107 RETURN TRUE;
1108
1109 ---===================== READY ====================
1110 ELSIF pST_STATUS= MSC_UTIL.G_ST_READY THEN
1111 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS,' pST_STATUS= MSC_UTIL.G_ST_READY');
1112 UPDATE MSC_APPS_INSTANCES
1113 SET ST_STATUS= MSC_UTIL.G_ST_READY,
1114 LAST_UPDATE_DATE= v_current_date,
1115 LAST_UPDATED_BY= v_current_user,
1116 REQUEST_ID= FND_GLOBAL.CONC_REQUEST_ID
1117 WHERE INSTANCE_ID= pINSTANCE_ID;
1118
1119 RETCODE:= MSC_UTIL.G_SUCCESS ;
1120 RETURN TRUE;
1121
1122 END IF;
1123
1124 END SET_ST_STATUS;
1125
1126
1127 PROCEDURE INITIALIZE( pINSTANCE_ID NUMBER)
1128 IS
1129 BEGIN
1130 -- retaining this function as it might be called by other packages.
1131 INITIALIZE_LOAD_GLOBALS( pINSTANCE_ID);
1132 END INITIALIZE;
1133
1134 PROCEDURE FINAL
1135 IS
1136 BEGIN
1137
1138 UPDATE MSC_APPS_INSTANCES mai
1139 SET LAST_UPDATE_DATE= v_current_date,
1140 LAST_UPDATED_BY= v_current_user,
1141 SUPPLIES_LOAD_FLAG = null,
1142 REQUEST_ID= FND_GLOBAL.CONC_REQUEST_ID
1143 WHERE mai.INSTANCE_ID= v_instance_id;
1144
1145 --- PREPLACE CHANGE START ---
1146
1147 -- DELETE FROM msc_coll_parameters
1148 -- WHERE instance_id = v_instance_id;
1149
1150
1151 --- PREPLACE CHANGE END ---
1152
1153 END FINAL;
1154
1155
1156 PROCEDURE DELETE_MSC_TABLE( p_table_name IN VARCHAR2,
1157 p_instance_id IN NUMBER,
1158 p_plan_id IN NUMBER:= NULL,
1159 p_sub_str IN VARCHAR2:= NULL) IS
1160
1161 -- lv_cnt NUMBER;
1162 lv_pbs NUMBER;
1163 lv_sql_stmt VARCHAR2(2048);
1164
1165 lv_task_start_time DATE;
1166
1167 lv_partition_name VARCHAR2(30);
1168 lv_is_plan NUMBER;
1169
1170 lv_return_status VARCHAR2(2048);
1171 lv_msg_data VARCHAR2(2048);
1172
1173 BEGIN
1174
1175 lv_task_start_time:= SYSDATE;
1176
1177 FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1178 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'DELETE_MSC_TABLE:'||p_table_name);
1179 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, ' '||FND_MESSAGE.GET);
1180 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, p_table_name||':'||p_sub_str);
1181 IF p_sub_str IS NULL AND
1182 is_msctbl_partitioned( p_table_name) THEN
1183 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, 'debug1');
1184
1185 IF p_plan_id= -1 OR p_plan_id IS NULL THEN
1186 lv_is_plan:= MSC_UTIL.SYS_NO;
1187 ELSE
1188 lv_is_plan:= MSC_UTIL.SYS_YES;
1189 END IF;
1190
1191 msc_manage_plan_partitions.get_partition_name
1192 ( p_plan_id,
1193 p_instance_id,
1194 p_table_name,
1195 lv_is_plan,
1196 lv_partition_name,
1197 lv_return_status,
1198 lv_msg_data);
1199
1200
1201 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, 'parameters passed to get_partiton_name are');
1202 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, 'p_plan_id'||p_plan_id);
1203 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, 'p_instance_id'||p_instance_id);
1204 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, 'p_table_name'||p_table_name);
1205 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, 'lv_is_plan'||lv_is_plan);
1206 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, 'lv_partition_name'||lv_partition_name);
1207 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, 'lv_return_status'||lv_return_status);
1208 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, 'lv_msg_data'||lv_msg_data);
1209
1210 lv_sql_stmt:= 'ALTER TABLE '||p_table_name
1211 ||' TRUNCATE PARTITION '||lv_partition_name;
1212
1213 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, lv_sql_stmt);
1214
1215 AD_DDL.DO_DDL( APPLSYS_SCHEMA => v_applsys_schema,
1216 APPLICATION_SHORT_NAME => 'MSC',
1217 STATEMENT_TYPE => AD_DDL.ALTER_TABLE,
1218 STATEMENT => lv_sql_stmt,
1219 OBJECT_NAME => p_table_name);
1220
1221 ELSE
1222
1223 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, 'debug2');
1224 lv_pbs:= TO_NUMBER( FND_PROFILE.VALUE('MRP_PURGE_BATCH_SIZE'));
1225 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, 'debug22:'||to_char(lv_pbs));
1226
1227 IF p_plan_id IS NULL THEN
1228
1229 /* lv_sql_stmt:= 'SELECT COUNT(*)'
1230 ||' FROM '||p_table_name
1231 ||' WHERE SR_INSTANCE_ID= :p_instance_id '
1232 || p_sub_str;
1233
1234 EXECUTE IMMEDIATE lv_sql_stmt
1235 INTO lv_cnt
1236 USING p_instance_id; */
1237
1238
1239 IF lv_pbs IS NULL THEN
1240
1241 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, 'debug200');
1242 lv_sql_stmt:= 'DELETE '||p_table_name
1243 ||' WHERE SR_INSTANCE_ID= :p_instance_id '
1244 || p_sub_str;
1245
1246 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, 'debug3');
1247 EXECUTE IMMEDIATE lv_sql_stmt
1248 USING p_instance_id;
1249
1250 COMMIT;
1251
1252 ELSE
1253
1254 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, 'debug4');
1255 lv_sql_stmt:= 'DELETE '||p_table_name
1256 ||' WHERE SR_INSTANCE_ID= :p_instance_id '
1257 || p_sub_str
1258 ||' AND ROWNUM < :lv_pbs';
1259
1260 LOOP
1261 EXECUTE IMMEDIATE lv_sql_stmt
1262 USING p_instance_id, lv_pbs;
1263
1264 EXIT WHEN SQL%ROWCOUNT= 0;
1265 COMMIT;
1266
1267 END LOOP;
1268 END IF; /* batch_size */
1269
1270 ELSE /* plan_id is not null */
1271
1272 /* lv_sql_stmt:= 'SELECT COUNT(*)'
1273 ||' FROM '||p_table_name
1274 ||' WHERE SR_INSTANCE_ID= :p_instance_id'
1275 ||' AND PLAN_ID= -1 '
1276 || p_sub_str;
1277
1278 EXECUTE IMMEDIATE lv_sql_stmt
1279 INTO lv_cnt
1280 USING p_instance_id; */
1281
1282 IF lv_pbs IS NULL THEN
1283
1284 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, 'debug5');
1285 lv_sql_stmt:= 'DELETE '||p_table_name
1286 ||' WHERE SR_INSTANCE_ID= :lv_instance_id'
1287 ||' AND PLAN_ID= -1 '
1288 || p_sub_str;
1289
1290 EXECUTE IMMEDIATE lv_sql_stmt
1291 USING p_instance_id;
1292
1293 COMMIT;
1294
1295 ELSE
1296
1297 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, 'debug300:'||p_sub_str);
1298 lv_sql_stmt:= 'DELETE '||p_table_name
1299 ||' WHERE SR_INSTANCE_ID= :p_instance_id '
1300 ||' AND PLAN_ID= -1 '
1301 || p_sub_str
1302 ||' AND ROWNUM < :lv_pbs';
1303
1304 LOOP
1305
1306 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, 'debug400:'||lv_sql_stmt);
1307 EXECUTE IMMEDIATE lv_sql_stmt
1308 USING p_instance_id, lv_pbs;
1309
1310 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, 'debug400');
1311
1312 EXIT WHEN SQL%ROWCOUNT= 0;
1313 COMMIT;
1314
1315 END LOOP;
1316
1317 END IF; /* batch_size */
1318 END IF; /* plan_id */
1319 END IF; /* is_msctbl_partitioned */
1320
1321 FND_MESSAGE.SET_NAME('MSC', 'MSC_ELAPSED_TIME');
1322 FND_MESSAGE.SET_TOKEN('ELAPSED_TIME',
1323 TO_CHAR(CEIL((SYSDATE- lv_task_start_time)*14400.0)/10));
1324 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, ' '||FND_MESSAGE.GET);
1325
1326 msc_util.print_top_wait(CEIL((SYSDATE- lv_task_start_time)*14400.0)/10);
1327 msc_util.print_cum_stat(CEIL((SYSDATE- lv_task_start_time)*14400.0)/10);
1328 msc_util.print_bad_sqls(CEIL((SYSDATE- lv_task_start_time)*14400.0)/10);
1329
1330 END DELETE_MSC_TABLE;
1331
1332 -- ========== End of Private Functions ==============
1333
1334 -- ========== Declare Local Procedures ==============
1335
1336 PROCEDURE EXECUTE_TASK( pSTATUS OUT NOCOPY NUMBER,
1337 pTASKNUM IN NUMBER);
1338
1339 /* to delete
1340 PROCEDURE LOAD_NET_RESOURCE_AVAIL;
1341 PROCEDURE LOAD_PROCESS_EFFECTIVITY ;
1342 PROCEDURE LOAD_OPERATION_COMPONENTS ;
1343 PROCEDURE LOAD_OPERATION_NETWORKS ;
1344 PROCEDURE LOAD_BOR;*/
1345
1346 /* CP-ACK starts */
1347 /* CP-ACK starts */
1348
1349 /* to delete
1350 PROCEDURE LOAD_ITEM;
1351 PROCEDURE LOAD_ABC_CLASSES;
1352
1353 PROCEDURE LOAD_SUB_INVENTORY;
1354 PROCEDURE LOAD_SOURCING;
1355 PROCEDURE LOAD_SUPPLIER_CAPACITY;
1356 PROCEDURE LOAD_CATEGORY;
1357 PROCEDURE LOAD_UNIT_NUMBER;
1358 PROCEDURE LOAD_SAFETY_STOCK;
1359 PROCEDURE LOAD_PROJECT;
1360 PROCEDURE LOAD_BIS_PFMC_MEASURES;
1361 PROCEDURE LOAD_BIS_TARGET_LEVELS;
1362 PROCEDURE LOAD_BIS_BUSINESS_PLANS;
1363 PROCEDURE LOAD_BIS_PERIODS;
1364 PROCEDURE LOAD_BIS_TARGETS;
1365 PROCEDURE LOAD_ATP_RULES;
1366 PROCEDURE LOAD_PLANNERS;
1367 PROCEDURE LOAD_DEMAND_CLASS;
1368
1369 PROCEDURE LOAD_SALES_CHANNEL;
1370 PROCEDURE LOAD_FISCAL_CALENDAR;
1371
1372 PROCEDURE LOAD_RES_REQ; -- called by load_supply
1373
1374 PROCEDURE LOAD_WIP_DEMAND; -- called by load_supply
1375
1376 PROCEDURE LOAD_ITEM_SUBSTITUTES; --for Product substitution
1377 PROCEDURE LOAD_JOB_DETAILS; --for job details
1378 PROCEDURE LOAD_JOB_OP_NWK;
1379 PROCEDURE LOAD_JOB_OP;
1380 PROCEDURE LOAD_JOB_REQ_OP;
1381 PROCEDURE LOAD_JOB_OP_RES;
1382 PROCEDURE LOAD_TRIP;*/
1383 /* ds change change start */
1384 /* to delete
1385 PROCEDURE LOAD_RES_INST_REQ;
1386 PROCEDURE LOAD_JOB_OP_RES_INSTANCE;
1387 PROCEDURE LOAD_RESOURCE_SETUP;
1388 PROCEDURE LOAD_RESOURCE_CHARGES;
1389 PROCEDURE LOAD_SETUP_TRANSITION;
1390 PROCEDURE LOAD_STD_OP_RESOURCES;*/
1391 /* ds change change end */
1392
1393 /** PREPLACE CHANGE START **/
1394 --agmcont:
1395 PROCEDURE EXECUTE_PARTIAL_TASK( pSTATUS OUT NOCOPY NUMBER,
1396 pTASKNUM IN NUMBER,
1397 prec in MSC_CL_EXCHANGE_PARTTBL.CollParamRec);
1398 -- This procedure provides a separate flow for
1399 -- Partial Replacement.
1400
1401
1402
1403 /** PREPLACE CHANGE END **/
1404
1405 -- =====Local Procedures =========
1406
1407 -- ========= EXECUTE_TASK ==========
1408
1409 /* LOAD_DESIGNATOR is moved to function TRANSFORM_KEYS */
1410 /* LOAD_UOM is moved to function TRANSFORM_KEYS */
1411
1412
1413
1414
1415 PROCEDURE EXECUTE_TASK( pSTATUS OUT NOCOPY NUMBER,
1416 pTASKNUM IN NUMBER)
1417
1418 IS
1419
1420 lv_task_start_time DATE;
1421 lv_lbj_details NUMBER := 0;
1422
1423 BEGIN
1424
1425
1426 lv_task_start_time:= SYSDATE;
1427
1428 --SAVEPOINT ExecuteTask;
1429
1430 pSTATUS := FAIL;
1431
1432 -- ============= Execute the task according to its task number ===========
1433
1434 IF pTASKNUM= TASK_SUPPLY THEN
1435
1436 update msc_apps_instances
1437 set SUPPLIES_LOAD_FLAG = G_JOB_NOT_DONE
1438 where instance_id = v_instance_id;
1439 commit;
1440
1441 FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1442 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SUPPLY_ODS_LOAD.LOAD_SUPPLY');
1443 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1444 MSC_CL_SUPPLY_ODS_LOAD.LOAD_SUPPLY;
1445
1446 IF v_is_complete_refresh AND v_exchange_mode=MSC_UTIL.SYS_NO THEN
1447 -- DELETE_MSC_TABLE( 'MSC_RESOURCE_REQUIREMENTS', v_instance_id, -1);
1448 -- DELETE_MSC_TABLE( 'MSC_DEMANDS', v_instance_id, -1 );
1449
1450 IF v_coll_prec.org_group_flag = MSC_UTIL.G_ALL_ORGANIZATIONS THEN
1451 DELETE_MSC_TABLE( 'MSC_RESOURCE_REQUIREMENTS', v_instance_id, -1);
1452 DELETE_MSC_TABLE( 'MSC_DEMANDS', v_instance_id, -1 );
1453 ELSE
1454 v_sub_str :=' AND ORGANIZATION_ID '||MSC_UTIL.v_in_org_str;
1455 DELETE_MSC_TABLE( 'MSC_RESOURCE_REQUIREMENTS', v_instance_id, -1,v_sub_str);
1456 DELETE_MSC_TABLE( 'MSC_DEMANDS', v_instance_id, -1 ,v_sub_str);
1457 END IF;
1458 ELSIF v_is_complete_refresh AND v_exchange_mode=MSC_UTIL.SYS_YES THEN
1459 IF v_coll_prec.org_group_flag = MSC_UTIL.G_ALL_ORGANIZATIONS THEN
1460 DELETE_MSC_TABLE( 'MSC_WO_ATTRIBUTES', v_instance_id, NULL );
1461 DELETE_MSC_TABLE( 'MSC_WO_OPERATION_REL', v_instance_id, NULL );
1462 DELETE_MSC_TABLE( 'MSC_WO_TASK_HIERARCHY', v_instance_id, NULL );
1463 ELSE
1464 v_sub_str :=' AND ORGANIZATION_ID '||MSC_UTIL.v_in_org_str;
1465 DELETE_MSC_TABLE( 'MSC_WO_ATTRIBUTES', v_instance_id, NULL ,v_sub_str);
1466 DELETE_MSC_TABLE( 'MSC_WO_OPERATION_REL', v_instance_id, NULL ,v_sub_str);
1467 DELETE_MSC_TABLE( 'MSC_WO_TASK_HIERARCHY', v_instance_id, NULL ,v_sub_str);
1468 END IF;
1469 END IF;
1470
1471
1472 IF ((v_coll_prec.org_group_flag <> MSC_UTIL.G_ALL_ORGANIZATIONS ) AND (v_exchange_mode = MSC_UTIL.SYS_YES)) THEN
1473 --(irrelevant now)For Continious (as in execute_partial_task before calling LOAD_SUPPLY in Continious collections
1474 -- exchange mode is set no) and incremental collections exchange_mode will be NO.The only left case is Complete collections.
1475 FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1476 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SUPPLY_ODS_LOAD.LOAD_ODS_SUPPLY');
1477 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1478 MSC_CL_SUPPLY_ODS_LOAD.LOAD_ODS_SUPPLY;
1479
1480 END IF;
1481
1482 update msc_apps_instances
1483 set SUPPLIES_LOAD_FLAG = G_JOB_DONE
1484 where instance_id = v_instance_id;
1485 commit;
1486
1487 MSC_CL_WIP_ODS_LOAD.LOAD_JOB_DETAILS;
1488
1489
1490 ELSIF pTASKNUM= TASK_MDS_DEMAND THEN
1491
1492 IF MSC_CL_SUPPLY_ODS_LOAD.IS_SUPPLIES_LOAD_DONE THEN
1493 FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1494 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LOAD_DEMAND');
1495 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1496 MSC_CL_DEMAND_ODS_LOAD.LOAD_DEMAND;
1497 ELSE
1498 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, 'Loading of Supplies failed.TASK_MDS_DEMAND');
1499 RAISE SUPPLIES_LOAD_FAIL;
1500 END IF;
1501
1502 ELSIF pTASKNUM= TASK_ITEM_FORECASTS THEN
1503
1504 FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1505 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LOAD_ITEM_FORECASTS');
1506 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1507 MSC_CL_DEMAND_ODS_LOAD.LOAD_ITEM_FORECASTS;
1508
1509 ELSIF pTASKNUM= TASK_WIP_COMP_DEMAND THEN
1510
1511 IF MSC_CL_SUPPLY_ODS_LOAD.IS_SUPPLIES_LOAD_DONE THEN
1512 FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1513 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_WIP_ODS_LOAD.LOAD_WIP_DEMAND');
1514 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1515 MSC_CL_WIP_ODS_LOAD.LOAD_WIP_DEMAND;
1516 ELSE
1517 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, 'Loading of Supplies failed.TASK_WIP_COMP_DEMAND');
1518 RAISE SUPPLIES_LOAD_FAIL;
1519 END IF;
1520
1521 ELSIF pTASKNUM= TASK_ODS_DEMAND THEN
1522
1523 IF ((v_coll_prec.org_group_flag <> MSC_UTIL.G_ALL_ORGANIZATIONS ) AND (v_exchange_mode = MSC_UTIL.SYS_YES)) THEN
1524
1525 FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1526 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LOAD_ODS_DEMAND');
1527 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1528 MSC_CL_DEMAND_ODS_LOAD.LOAD_ODS_DEMAND;
1529 ELSE
1530 NULL;
1531 END IF;
1532
1533 ELSIF pTASKNUM= TASK_RES_REQ THEN
1534
1535 IF MSC_CL_SUPPLY_ODS_LOAD.IS_SUPPLIES_LOAD_DONE THEN
1536 FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1537 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_WIP_ODS_LOAD.LOAD_RES_REQ');
1538 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1539 MSC_CL_WIP_ODS_LOAD.LOAD_RES_REQ;
1540 ELSE
1541 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, 'Loading of Supplies failed. TASK_RES_REQ');
1542 RAISE SUPPLIES_LOAD_FAIL;
1543 END IF;
1544
1545 ELSIF pTASKNUM= TASK_ODS_RES_REQ THEN
1546
1547 IF ((v_coll_prec.org_group_flag <> MSC_UTIL.G_ALL_ORGANIZATIONS ) AND (v_exchange_mode = MSC_UTIL.SYS_YES)) THEN
1548
1549 FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1550 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_WIP_ODS_LOAD.LOAD_ODS_RES_REQ');
1551 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1552 MSC_CL_WIP_ODS_LOAD.LOAD_ODS_RES_REQ;
1553 ELSE
1554 NULL;
1555 END IF;
1556
1557 ELSIF pTASKNUM= TASK_BOR THEN
1558
1559 FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1560 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_BOM_ODS_LOAD.LOAD_BOR');
1561 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1562 MSC_CL_BOM_ODS_LOAD.LOAD_BOR;
1563
1564 ELSIF pTASKNUM= TASK_CALENDAR_DATE THEN
1565
1566 FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1567 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SETUP_ODS_LOAD.LOAD_CALENDAR_DATE');
1568 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1569 MSC_CL_SETUP_ODS_LOAD.LOAD_CALENDAR_DATE;
1570
1571 ELSIF pTASKNUM= TASK_ITEM THEN
1572
1573 FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1574 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ITEM_ODS_LOAD.LOAD_ITEM');
1575 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1576 MSC_CL_ITEM_ODS_LOAD.LOAD_ITEM;
1577
1578 /* as Supplier capacity is depenedent on item call load_supplier capacity
1579 after load_item (support for net change of ASL)*/
1580
1581 FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1582 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ITEM_ODS_LOAD.LOAD_SUPPLIER_CAPACITY');
1583 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1584 MSC_CL_ITEM_ODS_LOAD.LOAD_SUPPLIER_CAPACITY;
1585
1586 FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1587 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SETUP_ODS_LOAD.CLEAN_LIAB_AGREEMENT');
1588 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1589 MSC_CL_SETUP_ODS_LOAD.CLEAN_LIAB_AGREEMENT;
1590
1591 ELSIF pTASKNUM= TASK_ABC_CLASSES THEN
1592
1593 FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1594 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ITEM_ODS_LOAD.LOAD_ABC_CLASSES');
1595 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1596 MSC_CL_ITEM_ODS_LOAD.LOAD_ABC_CLASSES;
1597
1598 ELSIF pTASKNUM= TASK_RESOURCE THEN
1599
1600 FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1601 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_BOM_ODS_LOAD.LOAD_RESOURCE');
1602 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1603 -- BUG # 3020614
1604 -- The call to the procedure LOAD_RESOURCE is being
1605 -- moved inside the procedure LOAD_CALENDAR_DATE.
1606
1607 -- LOAD_RESOURCE;
1608
1609 ELSIF pTASKNUM= TASK_SALES_ORDER THEN
1610
1611 IF MSC_CL_SUPPLY_ODS_LOAD.IS_SUPPLIES_LOAD_DONE THEN
1612 FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1613 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LOAD_SALES_ORDER');
1614 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1615 MSC_CL_DEMAND_ODS_LOAD.LOAD_SALES_ORDER;
1616
1617 IF (v_is_complete_refresh = TRUE and v_is_so_complete_refresh = FALSE) THEN
1618 IF (v_apps_ver >= MSC_UTIL.G_APPS115 ) THEN
1619 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, ' Calling Linking of Sales Order for 11i source ...');
1620 FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
1621 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LINK_SUPP_SO_DEMAND_11I2');
1622 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1623 MSC_CL_DEMAND_ODS_LOAD.LINK_SUPP_SO_DEMAND_11I2;
1624 -- Calling the Linking of external Sales orders for the fix 2353397 --
1625 -- MSC_CL_DEMAND_ODS_LOAD.LINK_SUPP_SO_DEMAND_EXT;
1626 ELSIF (v_apps_ver = MSC_UTIL.G_APPS110) THEN
1627 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, ' Calling Linking of Sales Order for 110 source ...');
1628 FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
1629 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LINK_SUPP_SO_DEMAND_110');
1630 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1631 MSC_CL_DEMAND_ODS_LOAD.LINK_SUPP_SO_DEMAND_110;
1632 END IF;
1633 END IF;
1634
1635 ELSE
1636 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, 'Loading of Supplies failed. sales order');
1637 RAISE SUPPLIES_LOAD_FAIL;
1638 END IF;
1639
1640 ELSIF pTASKNUM= TASK_SUB_INVENTORY THEN
1641
1642 FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1643 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_SUB_INVENTORY');
1644 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1645 MSC_CL_OTHER_ODS_LOAD.LOAD_SUB_INVENTORY;
1646
1647 ELSIF pTASKNUM= TASK_HARD_RESERVATION THEN
1648
1649 FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1650 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LOAD_HARD_RESERVATION');
1651 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1652 MSC_CL_DEMAND_ODS_LOAD.LOAD_HARD_RESERVATION;
1653
1654 ELSIF pTASKNUM= TASK_SOURCING THEN
1655
1656 FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1657 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_SOURCING');
1658 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1659 MSC_CL_OTHER_ODS_LOAD.LOAD_SOURCING;
1660 /* commented as a part of bug fix 5233688*/
1661
1662 ELSIF pTASKNUM= TASK_SUPPLIER_CAPACITY THEN
1663
1664 NULL;
1665
1666 /* FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1667 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'LOAD_SUPPLIER_CAPACITY');
1668 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1669 LOAD_SUPPLIER_CAPACITY;
1670 MSC_CL_SETUP_ODS_LOAD.CLEAN_LIAB_AGREEMENT ; */
1671
1672 /* SCE Change starts */
1673 /* ODS load for Customer cross reference Items */
1674 ELSIF pTASKNUM= TASK_ITEM_CUSTOMERS THEN
1675 FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1676 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'TASK_ITEM_CUSTOMERS');
1677 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1678 MSC_CL_SCE_COLLECTION.LOAD_ITEM_CUSTOMERS(v_instance_id);
1679
1680 ELSIF pTASKNUM= TASK_COMPANY_USERS THEN
1681
1682 /* Perform this task only if MSC:Configuration is set to 'APS + SCE' or 'SCE. */
1683 IF (MSC_UTIL.G_MSC_CONFIGURATION = MSC_UTIL.G_CONF_APS_SCE
1684 OR MSC_UTIL.G_MSC_CONFIGURATION = MSC_UTIL.G_CONF_SCE) THEN
1685
1686 FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1687 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SCE_COLLECTION.LOAD_USER_COMPANY');
1688 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1689 MSC_CL_SCE_COLLECTION.LOAD_USER_COMPANY(v_instance_id);
1690
1691 END IF;
1692 /* SCE Change ends */
1693
1694 ELSIF pTASKNUM= TASK_CATEGORY THEN
1695
1696 FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1697 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ITEM_ODS_LOAD.LOAD_CATEGORY');
1698 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1699 MSC_CL_ITEM_ODS_LOAD.LOAD_CATEGORY;
1700
1701 ELSIF pTASKNUM= TASK_BOM_COMPONENTS THEN
1702
1703 FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1704 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_BOM_ODS_LOAD.LOAD_BOM_COMPONENTS');
1705 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1706 MSC_CL_BOM_ODS_LOAD.LOAD_BOM_COMPONENTS;
1707
1708 ELSIF pTASKNUM= TASK_BOM THEN
1709
1710 FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1711 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_BOM_ODS_LOAD.LOAD_BOM');
1712 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1713 MSC_CL_BOM_ODS_LOAD.LOAD_BOM;
1714
1715 ELSIF pTASKNUM= TASK_COMPONENT_SUBSTITUTE THEN
1716
1717 FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1718 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_BOM_ODS_LOAD.LOAD_COMPONENT_SUBSTITUTE');
1719 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1720 MSC_CL_BOM_ODS_LOAD.LOAD_COMPONENT_SUBSTITUTE;
1721
1722 ELSIF pTASKNUM= TASK_ROUTING THEN
1723
1724 FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1725 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ROUTING_ODS_LOAD.LOAD_ROUTING');
1726 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1727 MSC_CL_ROUTING_ODS_LOAD.LOAD_ROUTING;
1728
1729 ELSIF pTASKNUM= TASK_ROUTING_OPERATIONS THEN
1730
1731 FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1732 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ROUTING_ODS_LOAD.LOAD_ROUTING_OPERATIONS');
1733 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1734 MSC_CL_ROUTING_ODS_LOAD.LOAD_ROUTING_OPERATIONS;
1735 ELSIF pTASKNUM= TASK_OPERATION_RESOURCES THEN
1736
1737 FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1738 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ROUTING_ODS_LOAD.LOAD_OPERATION_RESOURCES');
1739 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1740 MSC_CL_ROUTING_ODS_LOAD.LOAD_OPERATION_RESOURCES;
1741 ELSIF pTASKNUM= TASK_OP_RESOURCE_SEQ THEN
1742
1743 FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1744 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ROUTING_ODS_LOAD.LOAD_OP_RESOURCE_SEQ');
1745 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1746 MSC_CL_ROUTING_ODS_LOAD.LOAD_OP_RESOURCE_SEQ;
1747 ELSIF pTASKNUM= TASK_PROCESS_EFFECTIVITY THEN
1748
1749 FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1750 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_BOM_ODS_LOAD.LOAD_PROCESS_EFFECTIVITY');
1751 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1752 MSC_CL_BOM_ODS_LOAD.LOAD_PROCESS_EFFECTIVITY;
1753 ELSIF pTASKNUM= TASK_OPERATION_COMPONENTS THEN
1754
1755 FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1756 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ROUTING_ODS_LOAD.LOAD_OPERATION_COMPONENTS');
1757 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1758 MSC_CL_ROUTING_ODS_LOAD.LOAD_OPERATION_COMPONENTS;
1759 ELSIF pTASKNUM= TASK_OPERATION_NETWORKS THEN
1760
1761 FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1762 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ROUTING_ODS_LOAD.LOAD_OPERATION_NETWORKS');
1763 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1764 MSC_CL_ROUTING_ODS_LOAD.LOAD_OPERATION_NETWORKS;
1765
1766 ELSIF pTASKNUM= TASK_UNIT_NUMBER THEN
1767
1768 FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1769 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_UNIT_NUMBER');
1770 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1771 MSC_CL_OTHER_ODS_LOAD.LOAD_UNIT_NUMBER;
1772
1773 ELSIF pTASKNUM= TASK_SAFETY_STOCK THEN
1774
1775 FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1776 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_SAFETY_STOCK');
1777 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1778 MSC_CL_OTHER_ODS_LOAD.LOAD_SAFETY_STOCK;
1779
1780 ELSIF pTASKNUM= TASK_PROJECT THEN
1781
1782 FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1783 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_PROJECT');
1784 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1785 MSC_CL_OTHER_ODS_LOAD.LOAD_PROJECT;
1786
1787 ELSIF pTASKNUM= TASK_PARAMETER THEN
1788
1789 NULL;
1790
1791 -- Moved to the Main ODS Load, since we need this information in the function
1792 -- CALC_RESOURCE_AVAILABILITY called in LOAD_CALENDAR_DATE
1793
1794
1795 ELSIF pTASKNUM= TASK_BIS_PFMC_MEASURES THEN
1796
1797 IF v_apps_ver <> MSC_UTIL.G_APPS107 THEN
1798 FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1799 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_BIS_PFMC_MEASURES');
1800 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1801 MSC_CL_OTHER_ODS_LOAD.LOAD_BIS_PFMC_MEASURES;
1802 END IF;
1803
1804 ELSIF pTASKNUM= TASK_BIS_TARGET_LEVELS THEN
1805
1806 IF v_apps_ver <> MSC_UTIL.G_APPS107 THEN
1807 FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1808 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_BIS_TARGET_LEVELS');
1809 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1810 MSC_CL_OTHER_ODS_LOAD.LOAD_BIS_TARGET_LEVELS;
1811 END IF;
1812
1813 ELSIF pTASKNUM= TASK_BIS_TARGETS THEN
1814
1815 IF v_apps_ver <> MSC_UTIL.G_APPS107 THEN
1816 FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1817 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_BIS_TARGETS');
1818 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1819 MSC_CL_OTHER_ODS_LOAD.LOAD_BIS_TARGETS;
1820 END IF;
1821
1822 ELSIF pTASKNUM= TASK_BIS_BUSINESS_PLANS THEN
1823
1824 IF v_apps_ver <> MSC_UTIL.G_APPS107 THEN
1825 FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1826 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_BIS_BUSINESS_PLANS');
1827 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1828 MSC_CL_OTHER_ODS_LOAD.LOAD_BIS_BUSINESS_PLANS;
1829 END IF;
1830
1831 ELSIF pTASKNUM= TASK_BIS_PERIODS THEN
1832
1833 FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1834 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_BIS_PERIODS');
1835 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1836 MSC_CL_OTHER_ODS_LOAD.LOAD_BIS_PERIODS;
1837
1838 ELSIF pTASKNUM= TASK_ATP_RULES THEN
1839
1840 FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1841 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_ATP_RULES');
1842 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1843 MSC_CL_OTHER_ODS_LOAD.LOAD_ATP_RULES;
1844
1845 ELSIF pTASKNUM= TASK_NET_RESOURCE_AVAIL THEN
1846
1847 FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1848 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_RESOURCE_AVAILABILITY.LOAD_NET_RESOURCE_AVAIL');
1849 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1850 MSC_RESOURCE_AVAILABILITY.LOAD_NET_RESOURCE_AVAIL;
1851
1852 ELSIF pTASKNUM= TASK_PLANNERS THEN
1853
1854 FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1855 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_PLANNERS');
1856 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1857 MSC_CL_OTHER_ODS_LOAD.LOAD_PLANNERS;
1858
1859 ELSIF pTASKNUM= TASK_DEMAND_CLASS THEN
1860
1861 FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1862 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_DEMAND_CLASS');
1863 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1864 MSC_CL_OTHER_ODS_LOAD.LOAD_DEMAND_CLASS;
1865
1866 ELSIF pTASKNUM = TASK_ITEM_SUBSTITUTES THEN
1867
1868 IF (v_apps_ver >= MSC_UTIL.G_APPS115) OR v_is_legacy_refresh THEN
1869
1870 FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1871 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ITEM_ODS_LOAD.LOAD_ITEM_SUBSTITUTES');
1872 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1873 MSC_CL_ITEM_ODS_LOAD.LOAD_ITEM_SUBSTITUTES;
1874
1875 END IF;
1876
1877 ELSIF pTASKNUM= TASK_TRIP THEN
1878
1879 IF (v_apps_ver >= MSC_UTIL.G_APPS115) OR v_is_legacy_refresh THEN
1880
1881 FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1882 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_TRIP');
1883 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1884 MSC_CL_OTHER_ODS_LOAD.LOAD_TRIP;
1885
1886 END IF;
1887 /* ds change start */
1888 ELSIF pTASKNUM= TASK_RES_INST_REQ THEN
1889 IF MSC_CL_SUPPLY_ODS_LOAD.IS_SUPPLIES_LOAD_DONE THEN
1890 FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1891 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_WIP_ODS_LOAD.LOAD_RES_INST_REQ');
1892 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1893 MSC_CL_WIP_ODS_LOAD.LOAD_RES_INST_REQ;
1894 ELSE
1895 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, 'Loading of Supplies failed.TASK_RES_INST_REQ');
1896 RAISE SUPPLIES_LOAD_FAIL;
1897 END IF;
1898 ELSIF pTASKNUM= TASK_RESOURCE_SETUP THEN
1899 IF (v_apps_ver >= MSC_UTIL.G_APPS115) OR v_is_legacy_refresh THEN
1900 FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1901 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_BOM_ODS_LOAD.LOAD_RESOURCE_SETUP');
1902 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1903 MSC_CL_BOM_ODS_LOAD.LOAD_RESOURCE_SETUP;
1904 END IF;
1905 ELSIF pTASKNUM= TASK_SETUP_TRANSITION THEN
1906 IF (v_apps_ver >= MSC_UTIL.G_APPS115) OR v_is_legacy_refresh THEN
1907 FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1908 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_BOM_ODS_LOAD.LOAD_SETUP_TRANSITION');
1909 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1910 MSC_CL_BOM_ODS_LOAD.LOAD_SETUP_TRANSITION;
1911 END IF;
1912 ELSIF pTASKNUM= TASK_STD_OP_RESOURCES THEN
1913 IF (v_apps_ver >= MSC_UTIL.G_APPS115) OR v_is_legacy_refresh THEN
1914 FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1915 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ROUTING_ODS_LOAD.LOAD_STD_OP_RESOURCES');
1916 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1917 MSC_CL_ROUTING_ODS_LOAD.LOAD_STD_OP_RESOURCES;
1918 END IF;
1919 /* ds change end */
1920 ELSIF pTASKNUM= TASK_SALES_CHANNEL THEN
1921 FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1922 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_SALES_CHANNEL');
1923 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1924 -- LOG_MESSAGE(FND_MESSAGE.GET);
1925 MSC_CL_OTHER_ODS_LOAD.LOAD_SALES_CHANNEL;
1926 ELSIF pTASKNUM= TASK_FISCAL_CALENDAR THEN
1927 FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1928 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_FISCAL_CALENDAR');
1929 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1930 -- LOG_MESSAGE(FND_MESSAGE.GET);
1931 MSC_CL_OTHER_ODS_LOAD.LOAD_FISCAL_CALENDAR;
1932
1933 ELSIF pTASKNUM= TASK_PAYBACK_DEMAND_SUPPLY THEN
1934 FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1935 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LOAD_PAYBACK_DEMANDS');
1936 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS,FND_MESSAGE.GET);
1937 MSC_CL_DEMAND_ODS_LOAD.LOAD_PAYBACK_DEMANDS;
1938
1939 FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1940 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SUPPLY_ODS_LOAD.LOAD_PAYBACK_SUPPLIES');
1941 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS,FND_MESSAGE.GET);
1942 MSC_CL_SUPPLY_ODS_LOAD.LOAD_PAYBACK_SUPPLIES;
1943
1944 ELSIF pTASKNUM= TASK_CURRENCY_CONVERSION THEN ---- for bug # 6469722
1945 FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1946 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_CURRENCY_CONVERSION');
1947 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1948 IF (MSC_CL_OTHER_PULL.G_MSC_HUB_CURR_CODE IS NOT NULL) AND (v_apps_ver >= MSC_UTIL.G_APPS115) THEN
1949 MSC_CL_OTHER_ODS_LOAD.LOAD_CURRENCY_CONVERSION;
1950 ELSE
1951 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.');
1952 END IF;
1953
1954 ELSIF pTASKNUM= TASK_DELIVERY_DETAILS THEN ---- for bug # 6730983
1955 FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1956 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_DELIVERY_DETAILS');
1957 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1958 -- LOG_MESSAGE(FND_MESSAGE.GET);
1959 MSC_CL_OTHER_ODS_LOAD.LOAD_DELIVERY_DETAILS;
1960
1961 ELSIF pTASKNUM= TASK_IRO_DEMAND THEN -- Changed For bug 5909379 SRP Additions
1962
1963
1964
1965 IF MSC_CL_SUPPLY_ODS_LOAD.IS_SUPPLIES_LOAD_DONE THEN
1966 FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1967 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_RPO_ODS_LOAD.LOAD_IRO_DEMAND;');
1968 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1969 -- LOG_MESSAGE(FND_MESSAGE.GET);
1970 MSC_CL_RPO_ODS_LOAD.LOAD_IRO_DEMAND;
1971 END IF;
1972
1973
1974
1975 ELSIF pTASKNUM= TASK_ERO_DEMAND THEN -- Changed For bug 5935273 SRP Additions
1976
1977
1978
1979 IF MSC_CL_SUPPLY_ODS_LOAD.IS_SUPPLIES_LOAD_DONE THEN
1980 FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
1981 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_RPO_ODS_LOAD.LOAD_ERO_DEMAND;');
1982 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1983 --LOG_MESSAGE(FND_MESSAGE.GET);
1984 MSC_CL_RPO_ODS_LOAD.LOAD_ERO_DEMAND;
1985 END IF;
1986
1987 ELSIF pTASKNUM= TASK_CMRO THEN
1988
1989 IF (v_apps_ver >= MSC_UTIL.G_APPS121) AND v_is_legacy_refresh THEN
1990 FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
1991 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_VISITS');
1992 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
1993 MSC_CL_OTHER_ODS_LOAD.LOAD_VISITS;
1994 MSC_CL_OTHER_ODS_LOAD.LOAD_MILESTONES;
1995 MSC_CL_OTHER_ODS_LOAD.LOAD_WBS;
1996 MSC_CL_OTHER_ODS_LOAD.LOAD_WOATTRIBUTES;
1997 MSC_CL_OTHER_ODS_LOAD.LOAD_WO_TASK_HIERARCHY;
1998 MSC_CL_OTHER_ODS_LOAD.LOAD_WO_OPERATION_REL;
1999 END IF;
2000
2001 /* usaf */
2002
2003 ELSIF ( pTASKNUM= TASK_EAM_INFO ) THEN
2004 IF ( v_apps_ver >= MSC_UTIL.G_EAM_CMRO_SUP_VER
2005 AND MSC_UTIL.G_CMRO_EAM_INT_ENABLED = 'Y' ) THEN
2006 FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
2007 FND_MESSAGE.SET_TOKEN('PROCEDURE',
2008 'MSC_CL_EAM_ODS_LOAD.LOAD_EAM_INFO');
2009 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2010 MSC_CL_EAM_ODS_LOAD.LOAD_EAM_INFO ;
2011
2012 END IF;
2013 ELSIF ( pTASKNUM= TASK_EAM_FORECAST ) THEN
2014 IF ( v_apps_ver >= MSC_UTIL.G_EAM_CMRO_SUP_VER
2015 AND MSC_UTIL.G_CMRO_EAM_INT_ENABLED = 'Y' ) THEN
2016
2017 IF MSC_CL_SUPPLY_ODS_LOAD.IS_SUPPLIES_LOAD_DONE THEN
2018 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS,
2019 'Loading of Eam forecasts done');
2020 ELSE
2021 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS,
2022 'Loading of Supplies failed.TASK_EAM_FORECASTS');
2023 RAISE SUPPLIES_LOAD_FAIL;
2024 END IF;
2025
2026 END IF;
2027 ELSIF ( pTASKNUM= TASK_VISITS ) THEN
2028 IF ( v_apps_ver >= MSC_UTIL.G_EAM_CMRO_SUP_VER
2029 AND MSC_UTIL.G_CMRO_EAM_INT_ENABLED = 'Y' ) THEN
2030 FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
2031 FND_MESSAGE.SET_TOKEN('PROCEDURE',
2032 'MSC_CL_AHL_ODS_LOAD.TASK_VISITS');
2033 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2034 MSC_CL_AHL_ODS_LOAD.LOAD_VISITS;
2035 END IF;
2036 ELSIF ( pTASKNUM= TASK_WO_ATTRIBUTES ) THEN
2037 IF ( v_apps_ver >= MSC_UTIL.G_EAM_CMRO_SUP_VER
2038 AND MSC_UTIL.G_CMRO_EAM_INT_ENABLED = 'Y' ) THEN
2039
2040 IF MSC_CL_SUPPLY_ODS_LOAD.IS_SUPPLIES_LOAD_DONE THEN
2041 FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
2042 FND_MESSAGE.SET_TOKEN('PROCEDURE',
2043 'MSC_CL_AHL_ODS_LOAD.TASK_WO_ATTRIBUTES');
2044 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2045 MSC_CL_AHL_ODS_LOAD.LOAD_WO_ATTRIBUTES ;
2046 ELSE
2047 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS,
2048 'Loading of Supplies failed.TASK_WO_ATTRIBUTES');
2049 RAISE SUPPLIES_LOAD_FAIL;
2050 END IF;
2051
2052 END IF;
2053 ELSIF ( pTASKNUM= TASK_WO_TASK_HIERARCHY ) THEN
2054 IF ( v_apps_ver >= MSC_UTIL.G_EAM_CMRO_SUP_VER
2055 AND MSC_UTIL.G_CMRO_EAM_INT_ENABLED = 'Y' ) THEN
2056
2057 IF MSC_CL_SUPPLY_ODS_LOAD.IS_SUPPLIES_LOAD_DONE THEN
2058 FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
2059 FND_MESSAGE.SET_TOKEN('PROCEDURE',
2060 'MSC_CL_AHL_ODS_LOAD.LOAD_WO_TASK_HIERARCHY');
2061 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2062 MSC_CL_AHL_ODS_LOAD.LOAD_WO_TASK_HIERARCHY;
2063 ELSE
2064 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS,
2065 'Loading of Supplies failed.TASK_WO_TASK_HIERARCHY');
2066 RAISE SUPPLIES_LOAD_FAIL;
2067 END IF;
2068
2069 END IF;
2070 ELSIF ( pTASKNUM= TASK_WO_OPERATION_REL ) THEN
2071 IF ( v_apps_ver >= MSC_UTIL.G_EAM_CMRO_SUP_VER
2072 AND MSC_UTIL.G_CMRO_EAM_INT_ENABLED = 'Y' ) THEN
2073
2074 IF MSC_CL_SUPPLY_ODS_LOAD.IS_SUPPLIES_LOAD_DONE THEN
2075 FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
2076 FND_MESSAGE.SET_TOKEN('PROCEDURE',
2077 'MSC_CL_AHL_ODS_LOAD.LOAD_WO_OPERATION_REL');
2078 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2079 MSC_CL_AHL_ODS_LOAD.LOAD_WO_OPERATION_REL ;
2080 ELSE
2081 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS,
2082 'Loading of Supplies failed.TASK_WO_OPERATION_REL');
2083 RAISE SUPPLIES_LOAD_FAIL;
2084 END IF;
2085
2086 END IF;
2087 ELSIF ( pTASKNUM= TASK_WORK_BREAKDOWN_STRUCT ) THEN
2088 IF ( v_apps_ver >= MSC_UTIL.G_EAM_CMRO_SUP_VER
2089 AND MSC_UTIL.G_CMRO_EAM_INT_ENABLED = 'Y' ) THEN
2090 FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
2091 FND_MESSAGE.SET_TOKEN('PROCEDURE',
2092 'MSC_CL_AHL_ODS_LOAD.LOAD_WORK_BREAKDOWN_STRUCT');
2093 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2094 MSC_CL_AHL_ODS_LOAD.LOAD_WORK_BREAKDOWN_STRUCT;
2095 END IF;
2096 ELSIF ( pTASKNUM= TASK_WO_SUB_COMP ) THEN
2097 IF ( v_apps_ver >= MSC_UTIL.G_EAM_CMRO_SUP_VER
2098 AND MSC_UTIL.G_CMRO_EAM_INT_ENABLED = 'Y' ) THEN
2099 IF MSC_CL_SUPPLY_ODS_LOAD.IS_SUPPLIES_LOAD_DONE THEN
2100 FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
2101 FND_MESSAGE.SET_TOKEN('PROCEDURE',
2102 'MSC_CL_AHL_ODS_LOAD.LOAD_WO_SUB_COMP');
2103 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2104 MSC_CL_AHL_ODS_LOAD.LOAD_WO_SUB_COMP;
2105 ELSE
2106 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS,
2107 'Loading of Supplies failed.TASK_WO_SUB_COMP');
2108 END IF;
2109
2110 END IF;
2111 ELSIF ( pTASKNUM= TASK_WO_MILESTONES ) THEN
2112 IF ( v_apps_ver >= MSC_UTIL.G_EAM_CMRO_SUP_VER
2113 AND MSC_UTIL.G_CMRO_EAM_INT_ENABLED = 'Y' ) THEN
2114 FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
2115 FND_MESSAGE.SET_TOKEN('PROCEDURE',
2116 'MSC_CL_AHL_ODS_LOAD.LOAD_WO_MILESTONES');
2117 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2118 MSC_CL_AHL_ODS_LOAD.LOAD_WO_MILESTONES;
2119
2120 END IF;
2121 ELSIF ( pTASKNUM= TASK_CMRO_FORECAST_DEMANDS ) THEN
2122 IF ( v_apps_ver >= MSC_UTIL.G_EAM_CMRO_SUP_VER
2123 AND MSC_UTIL.G_CMRO_EAM_INT_ENABLED = 'Y' ) THEN
2124
2125 IF MSC_CL_SUPPLY_ODS_LOAD.IS_SUPPLIES_LOAD_DONE THEN
2126 FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
2127 FND_MESSAGE.SET_TOKEN('PROCEDURE',
2128 'MSC_CL_AHL_ODS_LOAD.LOAD_CMRO_FORECAST_DEMANDS ');
2129 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2130 MSC_CL_AHL_ODS_LOAD.LOAD_CMRO_FORECAST_DEMANDS ;
2131 ELSE
2132 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS,
2133 'Loading of Supplies failed.LOAD_CMRO_FORECAST_DEMANDS ');
2134 RAISE SUPPLIES_LOAD_FAIL;
2135 END IF;
2136 END IF;
2137 --mnagilla
2138 ELSIF ( pTASKNUM= TASK_EAM_FORECAST_DEMANDS ) THEN
2139 IF ( v_apps_ver >= MSC_UTIL.G_EAM_CMRO_SUP_VER
2140 AND MSC_UTIL.G_CMRO_EAM_INT_ENABLED = 'Y' ) THEN
2141
2142 IF MSC_CL_SUPPLY_ODS_LOAD.IS_SUPPLIES_LOAD_DONE THEN
2143 FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
2144 FND_MESSAGE.SET_TOKEN('PROCEDURE',
2145 'MSC_CL_EAM_ODS_LOAD.LOAD_EAM_FORECAST_DEMANDS ');
2146 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2147 MSC_CL_EAM_ODS_LOAD.LOAD_EAM_FORECAST_DEMANDS ;
2148 ELSE
2149 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS,
2150 'Loading of Supplies failed.LOAD_EAM_FORECAST_DEMANDS ');
2151 RAISE SUPPLIES_LOAD_FAIL;
2152 END IF;
2153 END IF; --mnagilla
2154 ELSIF ( pTASKNUM= TASK_CMRO_FORECAST_RR ) THEN
2155 IF ( v_apps_ver >= MSC_UTIL.G_EAM_CMRO_SUP_VER
2156 AND MSC_UTIL.G_CMRO_EAM_INT_ENABLED = 'Y' ) THEN
2157
2158 IF MSC_CL_SUPPLY_ODS_LOAD.IS_SUPPLIES_LOAD_DONE THEN
2159 FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
2160 FND_MESSAGE.SET_TOKEN('PROCEDURE',
2161 'MSC_CL_AHL_ODS_LOAD.LOAD_CMRO_FORECAST_RR ');
2162 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2163 MSC_CL_AHL_ODS_LOAD.LOAD_CMRO_FORECAST_RR ;
2164 ELSE
2165 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS,
2166 'Loading of Supplies failed.TASK_CMRO_FORECAST_RR');
2167 RAISE SUPPLIES_LOAD_FAIL;
2168 END IF;
2169 END IF;
2170 --mnagilla
2171 ELSIF ( pTASKNUM= TASK_EAM_FORECAST_RR ) THEN
2172 IF ( v_apps_ver >= MSC_UTIL.G_EAM_CMRO_SUP_VER
2173 AND MSC_UTIL.G_CMRO_EAM_INT_ENABLED = 'Y' ) THEN
2174
2175 IF MSC_CL_SUPPLY_ODS_LOAD.IS_SUPPLIES_LOAD_DONE THEN
2176 FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
2177 FND_MESSAGE.SET_TOKEN('PROCEDURE',
2178 'MSC_CL_EAM_ODS_LOAD.LOAD_EAM_FORECAST_RR ');
2179 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2180 MSC_CL_EAM_ODS_LOAD.LOAD_EAM_FORECAST_RR ;
2181 ELSE
2182 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS,
2183 'Loading of Supplies failed.TASK_EAM_FORECAST_RR');
2184 RAISE SUPPLIES_LOAD_FAIL;
2185 END IF;
2186 END IF; --mnagilla
2187 ELSIF ( pTASKNUM= TASK_CMRO_SUPP_RESRV ) THEN
2188 IF ( v_apps_ver >= MSC_UTIL.G_EAM_CMRO_SUP_VER
2189 AND MSC_UTIL.G_CMRO_EAM_INT_ENABLED = 'Y' ) THEN
2190 FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
2191 FND_MESSAGE.SET_TOKEN('PROCEDURE',
2192 'MSC_CL_AHL_ODS_LOAD.LOAD_SUPPLY_RESERVATIONS ');
2193 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2194 MSC_CL_AHL_ODS_LOAD.LOAD_SUPPLY_RESERVATIONS ;
2195 END IF;
2196 /* usaf*/
2197
2198 ELSIF ( pTASKNUM= TASK_CMRO_CLOSED_WO ) THEN
2199 MSC_UTIL.LOG_MSG (MSC_UTIL.G_D_STATUS,'in task closed cmro');
2200 IF ( v_apps_ver >= MSC_UTIL.G_EAM_CMRO_SUP_VER
2201 AND MSC_UTIL.G_CMRO_EAM_INT_ENABLED = 'Y' ) THEN
2202 FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2203 FND_MESSAGE.SET_TOKEN('PROCEDURE',
2204 'MSC_CL_AHL_ODS_LOAD.LOAD_CLOSED_CMRO_WOS');
2205 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2206 MSC_UTIL.LOG_MSG (MSC_UTIL.G_D_STATUS,'b4 ods proc call - closed WO');
2207 MSC_CL_AHL_ODS_LOAD.LOAD_CLOSED_CMRO_WOS;
2208 END IF;
2209
2210 ELSIF ( pTASKNUM= TASK_OSP_SUPPLY ) THEN
2211 MSC_UTIL.LOG_MSG (MSC_UTIL.G_D_STATUS,'in task osp supply');
2212
2213 IF ( v_apps_ver >= MSC_UTIL.G_EAM_CMRO_SUP_VER
2214 AND MSC_UTIL.G_CMRO_EAM_INT_ENABLED = 'Y' ) THEN
2215
2216 IF MSC_CL_SUPPLY_ODS_LOAD.IS_SUPPLIES_LOAD_DONE THEN
2217 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS,
2218 'Loading of OSP supplies done');
2219 ELSE
2220 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS,
2221 'Loading of Supplies failed.TASK_OSP_SUPPLY');
2222 RAISE SUPPLIES_LOAD_FAIL;
2223 END IF;
2224 END IF;
2225
2226 ELSIF pTASKNUM= TASK_IBUC_HISTORY THEN
2227 FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
2228 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_IB_CONTRACTS');
2229 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2230 MSC_CL_OTHER_ODS_LOAD.LOAD_IB_CONTRACTS;
2231
2232 ELSIF pTASKNUM= TASK_SHORT_TEXT THEN
2233 FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
2234 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_SHORT_TEXT');
2235 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2236 MSC_CL_OTHER_ODS_LOAD.LOAD_SHORT_TEXT;
2237
2238 ELSIF pTASKNUM= TASK_LONG_TEXT THEN
2239 FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
2240 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_LONG_TEXT');
2241 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2242 MSC_CL_OTHER_ODS_LOAD.LOAD_LONG_TEXT;
2243 ELSE
2244 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, 'Unhandled taskNum '||pTASKNUM);
2245 RAISE SUPPLIES_LOAD_FAIL;
2246
2247 END IF;
2248
2249 -- ======== If no EXCEPTION occurs, then returns with status = OK =========
2250
2251 pSTATUS := OK;
2252
2253 FND_MESSAGE.SET_NAME('MSC', 'MSC_ELAPSED_TIME');
2254 FND_MESSAGE.SET_TOKEN('ELAPSED_TIME',
2255 TO_CHAR(CEIL((SYSDATE- lv_task_start_time)*14400.0)/10));
2256 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2257
2258 msc_util.print_top_wait(CEIL((SYSDATE- lv_task_start_time)*14400.0)/10);
2259 msc_util.print_cum_stat(CEIL((SYSDATE- lv_task_start_time)*14400.0)/10);
2260 msc_util.print_bad_sqls(CEIL((SYSDATE- lv_task_start_time)*14400.0)/10);
2261
2262 EXCEPTION
2263
2264 WHEN SUPPLIES_LOAD_FAIL THEN
2265 ROLLBACK;
2266 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, SQLERRM);
2267 RAISE;
2268
2269 WHEN others THEN
2270
2271 -- ============= Raise the EXCEPTION ==============
2272 IF SQLCODE IN (-01578,-26040) THEN
2273 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR,SQLERRM);
2274 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR,'To rectify this problem -');
2275 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR,'Run concurrent program "Truncate Planning Staging Tables" ');
2276 END IF;
2277 --ROLLBACK WORK TO SAVEPOINT ExecuteTask;
2278 ROLLBACK;
2279
2280 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, SQLERRM);
2281
2282 RAISE;
2283
2284 END EXECUTE_TASK;
2285
2286 /*************** PREPLACE CHANGE START *****************/
2287
2288 PROCEDURE EXECUTE_PARTIAL_TASK( pSTATUS OUT NOCOPY NUMBER,
2289 pTASKNUM IN NUMBER,
2290 prec in MSC_CL_EXCHANGE_PARTTBL.CollParamRec)
2291
2292 IS
2293
2294 lv_task_start_time DATE;
2295
2296 --agmcont:
2297 lv_is_incremental_refresh boolean;
2298 lv_is_partial_refresh boolean;
2299 lv_exchange_mode number;
2300 lv_lbj_details number := 0;
2301
2302 BEGIN
2303
2304
2305 lv_task_start_time:= SYSDATE;
2306
2307 --SAVEPOINT ExecuteTask;
2308
2309 pSTATUS := FAIL;
2310
2311 -- agmcont
2312 if (v_is_cont_refresh) then
2313 if (MSC_CL_CONT_COLL_FW.set_cont_refresh_type_ODS(pTASKNUM, prec,
2314 lv_is_incremental_refresh,
2315 lv_is_partial_refresh,
2316 lv_exchange_mode)) then
2317
2318 IF ( pTASKNUM = PTASK_SALES_ORDER) THEN
2319 v_is_so_incremental_refresh := lv_is_incremental_refresh;
2320 v_is_so_complete_refresh := lv_is_partial_refresh;
2321 v_so_exchange_mode := lv_exchange_mode;
2322 ELSE
2323 v_is_incremental_refresh := lv_is_incremental_refresh;
2324 v_is_partial_refresh := lv_is_partial_refresh;
2325 v_exchange_mode := lv_exchange_mode;
2326 END IF;
2327
2328 if (v_is_incremental_refresh) then
2329 IF (MSC_UTIL.G_MSC_DEBUG <> 'N' ) THEN
2330 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, 'Task Num : '|| pTASKNUM||'. Incr Refresh Flag= True');
2331 END IF;
2332 else
2333 IF (MSC_UTIL.G_MSC_DEBUG <> 'N' ) THEN
2334 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, 'Task Num : '|| pTASKNUM||'. Incr Refresh Flag= False');
2335 END IF;
2336 end if;
2337
2338 if (v_is_partial_refresh) then
2339 IF (MSC_UTIL.G_MSC_DEBUG <> 'N' ) THEN
2340 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, 'Task Num : '|| pTASKNUM||'.Targeted Refresh Flag= True');
2341 END IF;
2342 else
2343
2344 IF (MSC_UTIL.G_MSC_DEBUG <> 'N' ) THEN
2345 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, 'Task Num : '|| pTASKNUM||'.Targeted Refresh Flag= False');
2346 END IF;
2347 end if;
2348
2349 else
2350 pSTATUS := OK;
2351 v_is_incremental_refresh := FALSE;
2352 v_is_partial_refresh := FALSE;
2353 v_exchange_mode := MSC_UTIL.SYS_NO;
2354 return;
2355 end if;
2356 end if;
2357
2358 -- ====== Execute the partial task according to its task number ==========
2359
2360 IF pTASKNUM= PTASK_SUPPLIER_CAPACITY THEN
2361 IF(prec.item_flag=MSC_UTIL.SYS_NO) THEN
2362 FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2363 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ITEM_ODS_LOAD.LOAD_SUPPLIER_CAPACITY');
2364 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2365 MSC_CL_ITEM_ODS_LOAD.LOAD_SUPPLIER_CAPACITY;
2366 MSC_CL_SETUP_ODS_LOAD.CLEAN_LIAB_AGREEMENT ;
2367 END IF ;
2368
2369 ELSIF pTASKNUM= PTASK_ITEM THEN
2370
2371 FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2372 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ITEM_ODS_LOAD.LOAD_ITEM');
2373 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2374 MSC_CL_ITEM_ODS_LOAD.LOAD_ITEM;
2375
2376 /* for bug 5233688 */
2377 IF(prec.app_supp_cap_flag=MSC_UTIL.SYS_YES or prec.app_supp_cap_flag=MSC_UTIL.ASL_YES_RETAIN_CP) THEN
2378 FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2379 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ITEM_ODS_LOAD.LOAD_SUPPLIER_CAPACITY');
2380 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2381 MSC_CL_ITEM_ODS_LOAD.LOAD_SUPPLIER_CAPACITY;
2382 MSC_CL_SETUP_ODS_LOAD.CLEAN_LIAB_AGREEMENT ;
2383 END IF ;
2384
2385 ELSIF pTASKNUM= PTASK_ABC_CLASSES THEN
2386
2387 FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2388 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ITEM_ODS_LOAD.LOAD_ABC_CLASSES');
2389 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2390 MSC_CL_ITEM_ODS_LOAD.LOAD_ABC_CLASSES;
2391
2392 ELSIF pTASKNUM= PTASK_CATEGORY_ITEM THEN
2393
2394 FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2395 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ITEM_ODS_LOAD.LOAD_CATEGORY');
2396 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2397 MSC_CL_ITEM_ODS_LOAD.LOAD_CATEGORY;
2398
2399 ELSIF pTASKNUM= PTASK_TRADING_PARTNER THEN
2400
2401 FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2402 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SETUP_ODS_LOAD.LOAD_TRADING_PARTNER');
2403 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2404 MSC_CL_SETUP_ODS_LOAD.LOAD_TRADING_PARTNER;
2405
2406 ELSIF pTASKNUM= PTASK_BOM_COMPONENTS THEN
2407
2408 FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2409 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_BOM_ODS_LOAD.LOAD_BOM_COMPONENTS');
2410 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2411 MSC_CL_BOM_ODS_LOAD.LOAD_BOM_COMPONENTS;
2412
2413 ELSIF pTASKNUM= PTASK_BOM THEN
2414
2415 FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2416 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_BOM_ODS_LOAD.LOAD_BOM');
2417 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2418 MSC_CL_BOM_ODS_LOAD.LOAD_BOM;
2419
2420 ELSIF pTASKNUM= PTASK_COMPONENT_SUBSTITUTE THEN
2421
2422 FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2423 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_BOM_ODS_LOAD.LOAD_COMPONENT_SUBSTITUTE');
2424 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2425 MSC_CL_BOM_ODS_LOAD.LOAD_COMPONENT_SUBSTITUTE;
2426
2427 ELSIF pTASKNUM= PTASK_ROUTING THEN
2428
2429 FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2430 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ROUTING_ODS_LOAD.LOAD_ROUTING');
2431 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2432 MSC_CL_ROUTING_ODS_LOAD.LOAD_ROUTING;
2433
2434 ELSIF pTASKNUM= PTASK_ROUTING_OPERATIONS THEN
2435
2436 FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2437 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ROUTING_ODS_LOAD.LOAD_ROUTING_OPERATIONS');
2438 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2439 MSC_CL_ROUTING_ODS_LOAD.LOAD_ROUTING_OPERATIONS;
2440
2441 ELSIF pTASKNUM= PTASK_OPERATION_RESOURCES THEN
2442
2443 FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2444 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ROUTING_ODS_LOAD.LOAD_OPERATION_RESOURCES');
2445 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2446 MSC_CL_ROUTING_ODS_LOAD.LOAD_OPERATION_RESOURCES;
2447
2448 ELSIF pTASKNUM= PTASK_RESOURCE THEN
2449
2450 FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2451 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'LOAD_RESOURCE');
2452 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2453 -- LOAD_RESOURCE;
2454
2455
2456 -- BUG # 3020614
2457 -- The call to the procedure LOAD_RESOURCE is being
2458 -- moved inside the procedure LOAD_CALENDAR_DATE.
2459
2460 if (v_coll_prec.calendar_flag = MSC_UTIL.SYS_NO) then
2461 MSC_CL_SETUP_ODS_LOAD.LOAD_CALENDAR_DATE;
2462 end if;
2463
2464 ELSIF pTASKNUM= PTASK_OP_RESOURCE_SEQ THEN
2465
2466 FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2467 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ROUTING_ODS_LOAD.LOAD_OP_RESOURCE_SEQ');
2468 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2469 MSC_CL_ROUTING_ODS_LOAD.LOAD_OP_RESOURCE_SEQ;
2470
2471 ELSIF pTASKNUM= PTASK_PROCESS_EFFECTIVITY THEN
2472
2473 FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2474 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_BOM_ODS_LOAD.LOAD_PROCESS_EFFECTIVITY');
2475 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2476 MSC_CL_BOM_ODS_LOAD.LOAD_PROCESS_EFFECTIVITY;
2477 -- Needs to be REVIEWED
2478
2479 ELSIF pTASKNUM= PTASK_OPERATION_COMPONENTS THEN
2480
2481 FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2482 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ROUTING_ODS_LOAD.LOAD_OPERATION_COMPONENTS');
2483 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2484 MSC_CL_ROUTING_ODS_LOAD.LOAD_OPERATION_COMPONENTS;
2485
2486 ELSIF pTASKNUM= PTASK_OPERATION_NETWORKS THEN
2487
2488 FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2489 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ROUTING_ODS_LOAD.LOAD_OPERATION_NETWORKS');
2490 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2491 MSC_CL_ROUTING_ODS_LOAD.LOAD_OPERATION_NETWORKS;
2492
2493 ELSIF pTASKNUM= PTASK_HARD_RESERVATION THEN
2494
2495 FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2496 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LOAD_HARD_RESERVATION');
2497 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2498 MSC_CL_DEMAND_ODS_LOAD.LOAD_HARD_RESERVATION;
2499
2500 ELSIF pTASKNUM= PTASK_SOURCING THEN
2501
2502 FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2503 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_SOURCING');
2504 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2505 MSC_CL_OTHER_ODS_LOAD.LOAD_SOURCING;
2506
2507 ELSIF pTASKNUM= PTASK_SAFETY_STOCK THEN
2508
2509 FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2510 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_SAFETY_STOCK');
2511 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2512 MSC_CL_OTHER_ODS_LOAD.LOAD_SAFETY_STOCK;
2513
2514 ELSIF pTASKNUM= PTASK_MDS_DEMAND THEN
2515
2516 -- If any of the supply flags are enabled then wait for the supplies to be completed
2517 -- no need to call the load_demand routine
2518 -- since the SUPPLY task will handle it.
2519 /* In Cont. collections cal the Load_demand here only if these conds. are satisfied:
2520 1. None of the Supplies are not collected
2521 2. MDS is Targeted OR ( MDS is incremental Refresh and other Demand (forecast) is Not Targeted)
2522 IF Forecast is targeted and MDS Is incremental then, LOAD_DEMAND will be called in TASK_ODS_DEMANDS */
2523
2524 IF NOT(v_is_cont_refresh) OR -- Not Automatic collections i.e. Incremenatal or Targeted
2525 ((v_is_cont_refresh) AND
2526 ((v_coll_prec.mds_flag = MSC_UTIL.SYS_YES and v_coll_prec.mds_sn_flag = MSC_UTIL.SYS_TGT) OR
2527 ((v_coll_prec.mds_flag = MSC_UTIL.SYS_YES and v_coll_prec.mds_sn_flag = MSC_UTIL.SYS_INCR) AND
2528 (
2529 (v_coll_prec.forecast_flag = MSC_UTIL.SYS_NO or
2530 (v_coll_prec.forecast_flag = MSC_UTIL.SYS_YES AND v_coll_prec.fcst_sn_flag <>MSC_UTIL.SYS_TGT)) AND
2531 (v_coll_prec.wip_flag = MSC_UTIL.SYS_NO or
2532 (v_coll_prec.wip_flag = MSC_UTIL.SYS_YES and v_coll_prec.wip_sn_flag <>MSC_UTIL.SYS_TGT)) AND
2533 (v_coll_prec.user_supply_demand_flag = MSC_UTIL.SYS_NO or
2534 (v_coll_prec.user_supply_demand_flag = MSC_UTIL.SYS_YES and v_coll_prec.udmd_sn_flag <>MSC_UTIL.SYS_TGT))
2535 )))) THEN
2536 IF ( (v_coll_prec.mps_flag = MSC_UTIL.SYS_YES) or
2537 (v_coll_prec.po_flag = MSC_UTIL.SYS_YES) or
2538 (v_coll_prec.oh_flag = MSC_UTIL.SYS_YES) or
2539 (v_coll_prec.wip_flag = MSC_UTIL.SYS_YES) or
2540 (v_coll_prec.supplier_response_flag = MSC_UTIL.SYS_YES) or
2541 (v_coll_prec.user_supply_demand_flag = MSC_UTIL.SYS_YES) ) THEN
2542
2543 IF MSC_CL_SUPPLY_ODS_LOAD.IS_SUPPLIES_LOAD_DONE THEN
2544 FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2545 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LOAD_DEMAND');
2546 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2547 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');
2548 MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'or all the demands are incremental or None in this run. ');
2549 MSC_CL_DEMAND_ODS_LOAD.LOAD_DEMAND;
2550 ELSE
2551 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, 'Loading of Supplies failed.mps etc');
2552 RAISE SUPPLIES_LOAD_FAIL;
2553 END IF;
2554
2555 ELSE
2556 FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2557 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LOAD_DEMAND');
2558 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2559 MSC_CL_DEMAND_ODS_LOAD.LOAD_DEMAND;
2560 END IF;
2561
2562 END IF;
2563
2564 ELSIF pTASKNUM = PTASK_WIP_RES_REQ THEN
2565
2566 IF MSC_CL_SUPPLY_ODS_LOAD.IS_SUPPLIES_LOAD_DONE THEN
2567 FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2568 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_WIP_ODS_LOAD.LOAD_RES_REQ');
2569 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2570 MSC_CL_WIP_ODS_LOAD.LOAD_RES_REQ;
2571 --MSC_CL_WIP_ODS_LOAD.LOAD_ODS_RES_REQ;
2572 ELSE
2573 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, 'Loading of Supplies failed. PTASK_WIP_RES_REQ');
2574 RAISE SUPPLIES_LOAD_FAIL;
2575 END IF;
2576
2577 ELSIF pTASKNUM = PTASK_WIP_DEMAND THEN
2578
2579 IF NOT(v_is_cont_refresh) OR -- Not Automatic collections i.e. Incremenatal or Targeted
2580 ((v_is_cont_refresh) AND
2581 ((v_coll_prec.wip_flag = MSC_UTIL.SYS_YES and v_coll_prec.wip_sn_flag = MSC_UTIL.SYS_TGT) OR
2582 ((v_coll_prec.wip_flag = MSC_UTIL.SYS_YES and v_coll_prec.wip_sn_flag = MSC_UTIL.SYS_INCR) AND
2583 ((v_coll_prec.forecast_flag = MSC_UTIL.SYS_NO or
2584 (v_coll_prec.forecast_flag = MSC_UTIL.SYS_YES and v_coll_prec.fcst_sn_flag <>MSC_UTIL.SYS_TGT)) AND
2585 (v_coll_prec.mds_flag = MSC_UTIL.SYS_NO or
2586 (v_coll_prec.mds_flag = MSC_UTIL.SYS_YES and v_coll_prec.mds_sn_flag <>MSC_UTIL.SYS_TGT)) AND
2587 (v_coll_prec.user_supply_demand_flag = MSC_UTIL.SYS_NO or
2588 (v_coll_prec.user_supply_demand_flag = MSC_UTIL.SYS_YES and v_coll_prec.udmd_sn_flag <>MSC_UTIL.SYS_TGT))
2589 ) ))) THEN
2590 IF MSC_CL_SUPPLY_ODS_LOAD.IS_SUPPLIES_LOAD_DONE THEN
2591 FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2592 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_WIP_ODS_LOAD.LOAD_WIP_DEMAND');
2593 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2594 MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'Calling LOAD_WIP_DEMAND From PTASK_WIP_DEMAND -- Either WIP is Targetted ');
2595 MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'or all the demands are incremental or None in this run. ');
2596 MSC_CL_WIP_ODS_LOAD.LOAD_WIP_DEMAND;
2597 ELSE
2598 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, 'Loading of Supplies failed.LOAD_WIP_DEMAND');
2599 RAISE SUPPLIES_LOAD_FAIL;
2600 END IF;
2601 END IF;
2602
2603 ELSIF pTASKNUM= PTASK_FORECAST_DEMAND THEN
2604
2605 IF NOT(v_is_cont_refresh) OR -- Not Automatic collections i.e. Incremenatal or Targeted
2606 ((v_is_cont_refresh) AND
2607 ((v_coll_prec.forecast_flag = MSC_UTIL.SYS_YES and v_coll_prec.fcst_sn_flag = MSC_UTIL.SYS_TGT) OR
2608 ((v_coll_prec.forecast_flag = MSC_UTIL.SYS_YES and v_coll_prec.fcst_sn_flag = MSC_UTIL.SYS_INCR) AND
2609 ((v_coll_prec.mds_flag = MSC_UTIL.SYS_NO or
2610 (v_coll_prec.mds_flag = MSC_UTIL.SYS_YES and v_coll_prec.mds_sn_flag <>MSC_UTIL.SYS_TGT)) AND
2611 (v_coll_prec.wip_flag = MSC_UTIL.SYS_NO or
2612 (v_coll_prec.wip_flag = MSC_UTIL.SYS_YES and v_coll_prec.wip_sn_flag <>MSC_UTIL.SYS_TGT)) AND
2613 (v_coll_prec.user_supply_demand_flag = MSC_UTIL.SYS_NO or
2614 (v_coll_prec.user_supply_demand_flag = MSC_UTIL.SYS_YES and v_coll_prec.udmd_sn_flag <>MSC_UTIL.SYS_TGT))
2615 )))) THEN
2616
2617 FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2618 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'LOAD_ITEM_FORECAST');
2619 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2620 MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'Calling LOAD_ITEM_FORECAST From PTASK_FORECAST_DEMAND-- Either forecast id Targetted ');
2621 MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'or all the demands are incremental or None in this run. ');
2622 MSC_CL_DEMAND_ODS_LOAD.LOAD_ITEM_FORECASTS;
2623
2624 END IF;
2625
2626
2627 /* IN Cont. Collections, This Task will do the Incremental of MDS or Forecast
2628 if one of them is targeted and other is Incremental
2629 This task will be called only if none of the Supplies are collected */
2630
2631 ELSIF pTASKNUM= PTASK_ODS_DEMAND THEN
2632 IF (v_is_cont_refresh) then
2633 -- Is any Demand Targetted in Continous, then modify any other incremental demand first
2634 IF ( (v_coll_prec.forecast_flag = MSC_UTIL.SYS_YES and v_coll_prec.fcst_sn_flag = MSC_UTIL.SYS_TGT) OR
2635 (v_coll_prec.wip_flag = MSC_UTIL.SYS_YES and v_coll_prec.wip_sn_flag = MSC_UTIL.SYS_TGT) OR
2636 (v_coll_prec.user_supply_demand_flag = MSC_UTIL.SYS_YES and v_coll_prec.udmd_sn_flag = MSC_UTIL.SYS_TGT) OR
2637 (v_coll_prec.mds_flag = MSC_UTIL.SYS_YES and v_coll_prec.mds_sn_flag = MSC_UTIL.SYS_TGT) ) THEN
2638
2639 IF (v_coll_prec.forecast_flag = MSC_UTIL.SYS_YES and v_coll_prec.fcst_sn_flag = MSC_UTIL.SYS_INCR) THEN
2640 FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2641 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'LOAD_ITEM_FORECAST');
2642 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2643 v_is_incremental_refresh := TRUE;
2644 v_exchange_mode := MSC_UTIL.SYS_NO;
2645 MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'Calling Incremental MSC_CL_DEMAND_ODS_LOAD.LOAD_ITEM_FORECASTS From PTASK_ODS_DEMAND');
2646 MSC_CL_DEMAND_ODS_LOAD.LOAD_ITEM_FORECASTS;
2647 END IF;
2648
2649 IF (v_coll_prec.wip_flag = MSC_UTIL.SYS_YES and v_coll_prec.wip_sn_flag = MSC_UTIL.SYS_INCR) THEN
2650 IF MSC_CL_SUPPLY_ODS_LOAD.IS_SUPPLIES_LOAD_DONE THEN
2651 FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2652 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_WIP_ODS_LOAD.LOAD_WIP_DEMAND');
2653 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2654 v_is_incremental_refresh := TRUE;
2655 v_exchange_mode := MSC_UTIL.SYS_NO;
2656 MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'Calling Incremental LOAD_WIP_DEMAND From PTASK_ODS_DEMAND');
2657 MSC_CL_WIP_ODS_LOAD.LOAD_WIP_DEMAND;
2658 ELSE
2659 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, 'Loading of Supplies failed.LOAD_WIP_DEMAND');
2660 RAISE SUPPLIES_LOAD_FAIL;
2661 END IF;
2662
2663 END IF; ---any supply flag is yes, no need to handle no supplies
2664
2665 IF (v_coll_prec.mds_flag = MSC_UTIL.SYS_YES and v_coll_prec.mds_sn_flag = MSC_UTIL.SYS_INCR) THEN
2666 IF ( (v_coll_prec.mps_flag = MSC_UTIL.SYS_YES) or
2667 (v_coll_prec.po_flag = MSC_UTIL.SYS_YES) or
2668 (v_coll_prec.oh_flag = MSC_UTIL.SYS_YES) or
2669 (v_coll_prec.wip_flag = MSC_UTIL.SYS_YES) or
2670 (v_coll_prec.supplier_response_flag = MSC_UTIL.SYS_YES) or
2671 (v_coll_prec.user_supply_demand_flag = MSC_UTIL.SYS_YES) ) THEN
2672
2673 IF MSC_CL_SUPPLY_ODS_LOAD.IS_SUPPLIES_LOAD_DONE THEN
2674 FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2675 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LOAD_DEMAND');
2676 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2677 v_is_incremental_refresh := TRUE;
2678 v_exchange_mode := MSC_UTIL.SYS_NO;
2679 MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'Calling Incremental MSC_CL_DEMAND_ODS_LOAD.LOAD_DEMAND From PTASK_ODS_DEMAND');
2680 MSC_CL_DEMAND_ODS_LOAD.LOAD_DEMAND;
2681 ELSE
2682 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, ' Loading of Supplies failed MSC_CL_DEMAND_ODS_LOAD.LOAD_DEMAND');
2683 RAISE SUPPLIES_LOAD_FAIL;
2684 END IF;
2685
2686 ELSE --- all the supplies flag are no
2687 FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2688 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LOAD_DEMAND');
2689 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2690 v_is_incremental_refresh := TRUE;
2691 v_exchange_mode := MSC_UTIL.SYS_NO;
2692 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');
2693 MSC_CL_DEMAND_ODS_LOAD.LOAD_DEMAND;
2694 END IF; ---any supply flag is yes
2695
2696 END IF;
2697
2698
2699
2700 /* AFTER HANDLING OTHER DEMANDS INCREMENTAL PERFORM THE MSC_CL_DEMAND_ODS_LOAD.LOAD_ODS_DEMAND */
2701 /* -------------------------------------------------------------------- */
2702
2703 FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2704 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LOAD_ODS_DEMAND');
2705 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2706 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');
2707 MSC_CL_DEMAND_ODS_LOAD.LOAD_ODS_DEMAND;
2708
2709
2710
2711 END IF; -- Is any Demand Targetted in Continous
2712
2713 elsif (v_is_partial_refresh) THEN -- Targeted collections
2714
2715 FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2716 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LOAD_ODS_DEMAND');
2717 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2718 MSC_CL_DEMAND_ODS_LOAD.LOAD_ODS_DEMAND;
2719 -- Load Demand information from ODS table into
2720 -- the temp table.
2721
2722 end if;
2723
2724 /*bug 13849666*/
2725
2726 ELSIF pTASKNUM= PTASK_ODS_RES_REQ THEN
2727 IF (v_is_cont_refresh) then
2728
2729 IF ( (v_coll_prec.wip_flag = MSC_UTIL.SYS_YES ) OR
2730 (v_coll_prec.cmro_forecasts_flag = MSC_UTIL.SYS_YES) or
2731 (v_coll_prec.eam_forecasts_flag = MSC_UTIL.SYS_YES) ) THEN
2732
2733
2734 IF MSC_CL_SUPPLY_ODS_LOAD.IS_SUPPLIES_LOAD_DONE THEN
2735 FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2736 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_WIP_ODS_LOAD.LOAD_RES_REQ');
2737 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2738 v_is_incremental_refresh := TRUE;
2739 v_exchange_mode := MSC_UTIL.SYS_NO;
2740 MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'Calling Incremental LOAD_RES_REQ From PTASK_ODS_RES_REQ');
2741 MSC_CL_WIP_ODS_LOAD.LOAD_RES_REQ;
2742 ELSE
2743 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, 'Loading of Supplies failed.LOAD_RES_REQ');
2744 RAISE SUPPLIES_LOAD_FAIL;
2745 END IF;
2746
2747
2748 /* AFTER HANDLING OTHER res req INCREMENTAL PERFORM THE MSC_CL_WIP_ODS_LOAD.LOAD_ODS_RES_REQ */
2749 /* --------------------------------------------------------------------
2750
2751 FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2752 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_WIP_ODS_LOAD.LOAD_ODS_RES_REQ');
2753 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2754 MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'Calling MSC_CL_WIP_ODS_LOAD.LOAD_ODS_RES_REQ From PTASK_ODS_RES_REQ ');
2755 MSC_CL_WIP_ODS_LOAD.LOAD_ODS_RES_REQ; */
2756
2757
2758
2759 END IF;
2760
2761 elsif (v_is_partial_refresh) THEN -- Targeted collections
2762
2763 FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2764 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_WIP_ODS_LOAD.LOAD_ODS_RES_REQ');
2765 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2766 MSC_CL_WIP_ODS_LOAD.LOAD_ODS_RES_REQ;
2767 -- Load res req information from ODS table into the temp table.
2768
2769 end if;
2770
2771 /*bug 13849666*/
2772
2773 ELSIF pTASKNUM= PTASK_SUPPLY THEN
2774 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, 'ds debug: pTASKNUM= PTASK_SUPPLY ');
2775
2776 update msc_apps_instances
2777 set SUPPLIES_LOAD_FLAG = G_JOB_NOT_DONE
2778 where instance_id = v_instance_id;
2779 commit;
2780
2781 /* AGM NCP: */
2782
2783 --agmcont
2784 IF (v_is_cont_refresh) then
2785
2786 -- in continuous collections, it is possible to have
2787 -- a supply entity collected in net-change mode
2788 -- and other supply entities to be collected in targeted mode
2789
2790 -- first call load_supply to handle any supply
2791 -- entities (po/oh/wip/mps) which are being collected
2792 -- net-change
2793 MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'PTASK_SUPPLY: v_is_cont_refresh = true');
2794 if (v_coll_prec.mps_flag = MSC_UTIL.SYS_YES and v_coll_prec.mps_sn_flag = MSC_UTIL.SYS_INCR) or
2795 (v_coll_prec.wip_flag = MSC_UTIL.SYS_YES and v_coll_prec.wip_sn_flag = MSC_UTIL.SYS_INCR) or
2796 (v_coll_prec.po_flag = MSC_UTIL.SYS_YES and v_coll_prec.po_sn_flag = MSC_UTIL.SYS_INCR) or
2797 /* CP-AUTO */
2798 (v_coll_prec.supplier_response_flag = MSC_UTIL.SYS_YES and v_coll_prec.suprep_sn_flag = MSC_UTIL.SYS_INCR) or
2799 (v_coll_prec.oh_flag = MSC_UTIL.SYS_YES and v_coll_prec.oh_sn_flag = MSC_UTIL.SYS_INCR) or
2800 (v_coll_prec.user_supply_demand_flag = MSC_UTIL.SYS_YES and v_coll_prec.usup_sn_flag = MSC_UTIL.SYS_INCR)
2801 then
2802
2803 FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2804 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SUPPLY_ODS_LOAD.LOAD_SUPPLY');
2805 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2806 v_exchange_mode := MSC_UTIL.SYS_NO;
2807 MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'PTASK_SUPPLY: before MSC_CL_SUPPLY_ODS_LOAD.LOAD_SUPPLY ');
2808 MSC_CL_SUPPLY_ODS_LOAD.LOAD_SUPPLY;
2809 MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'PTASK_SUPPLY: after MSC_CL_SUPPLY_ODS_LOAD.LOAD_SUPPLY ');
2810 end if;
2811
2812 -- now call load_staging_supply and load_ods_supply
2813 -- to collect the supply entities that are collected in
2814 -- targeted mode
2815
2816 if (v_coll_prec.mps_flag = MSC_UTIL.SYS_YES and v_coll_prec.mps_sn_flag = MSC_UTIL.SYS_TGT) or
2817 (v_coll_prec.wip_flag = MSC_UTIL.SYS_YES and v_coll_prec.wip_sn_flag = MSC_UTIL.SYS_TGT) or
2818 (v_coll_prec.po_flag = MSC_UTIL.SYS_YES and v_coll_prec.po_sn_flag = MSC_UTIL.SYS_TGT) or
2819 (v_coll_prec.oh_flag = MSC_UTIL.SYS_YES and v_coll_prec.oh_sn_flag = MSC_UTIL.SYS_TGT) or
2820 /* CP-AUTO */
2821 (v_coll_prec.supplier_response_flag = MSC_UTIL.SYS_YES and v_coll_prec.suprep_sn_flag = MSC_UTIL.SYS_TGT) or
2822 (v_coll_prec.user_supply_demand_flag = MSC_UTIL.SYS_YES and v_coll_prec.usup_sn_flag = MSC_UTIL.SYS_TGT) or
2823 (v_coll_prec.eam_forecasts_flag = MSC_UTIL.SYS_YES) or
2824 (v_coll_prec.cmro_forecasts_flag = MSC_UTIL.SYS_YES) or
2825 (v_coll_prec.cmro_closed_wo = MSC_UTIL.SYS_YES or
2826 (v_coll_prec.osp_supply = MSC_UTIL.SYS_YES) ) then
2827 -- Load Supply information from staging tables
2828 -- into the temp table.
2829 FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2830 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SUPPLY_ODS_LOAD.LOAD_STAGING_SUPPLY');
2831 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2832 MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'PTASK_SUPPLY: before MSC_CL_SUPPLY_ODS_LOAD.LOAD_STAGING_SUPPLY ');
2833 MSC_CL_SUPPLY_ODS_LOAD.LOAD_STAGING_SUPPLY;
2834 MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'PTASK_SUPPLY: after MSC_CL_SUPPLY_ODS_LOAD.LOAD_STAGING_SUPPLY ');
2835 -- Load Supply information from ODS table
2836 -- into the temp table.
2837 FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2838 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SUPPLY_ODS_LOAD.LOAD_ODS_SUPPLY');
2839 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2840 MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'PTASK_SUPPLY: befor MSC_CL_SUPPLY_ODS_LOAD.LOAD_ODS_SUPPLY ');
2841 MSC_CL_SUPPLY_ODS_LOAD.LOAD_ODS_SUPPLY;
2842 MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'PTASK_SUPPLY: after MSC_CL_SUPPLY_ODS_LOAD.LOAD_ODS_SUPPLY ');
2843
2844 IF MSC_CL_SUPPLY_ODS_LOAD.create_supplies_tmp_ind THEN
2845 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, 'Index creation on Temp Supplies table successful.');
2846 ELSE
2847 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, SQLERRM);
2848 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, 'Index creation on Temp Supplies table failed.');
2849 RAISE SUPPLIES_INDEX_FAIL;
2850 END IF;
2851
2852 msc_analyse_tables_pk.analyse_table( 'SUPPLIES_'||v_instance_code, v_instance_id, -1);
2853
2854 end if; --- any one of the Supplies will be done Targeted
2855
2856 ELSIF (v_is_incremental_refresh) then
2857 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, 'ds debug: v_is_incremental_refresh MSC_CL_SUPPLY_ODS_LOAD.LOAD_SUPPLY');
2858 FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2859 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SUPPLY_ODS_LOAD.LOAD_SUPPLY');
2860 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2861 MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'PTASK_SUPPLY:v_is_incremental_refresh before MSC_CL_SUPPLY_ODS_LOAD.LOAD_SUPPLY ');
2862 MSC_CL_SUPPLY_ODS_LOAD.LOAD_SUPPLY;
2863 MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'PTASK_SUPPLY:v_is_incremental_refresh after MSC_CL_SUPPLY_ODS_LOAD.LOAD_SUPPLY ');
2864 ELSE ---- Targeted Collections
2865 -- Load Supply information from staging tables
2866 -- into the temp table.
2867 MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'ds debug: Targetted MSC_CL_SUPPLY_ODS_LOAD.LOAD_ODS_SUPPLY');
2868 FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2869 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SUPPLY_ODS_LOAD.LOAD_STAGING_SUPPLY');
2870 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2871 MSC_CL_SUPPLY_ODS_LOAD.LOAD_STAGING_SUPPLY;
2872 -- Load Supply information from ODS table
2873 -- into the temp table.
2874 FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2875 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SUPPLY_ODS_LOAD.LOAD_ODS_SUPPLY');
2876 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2877 MSC_CL_SUPPLY_ODS_LOAD.LOAD_ODS_SUPPLY;
2878
2879 /*added by raraghav*/
2880
2881 /* analyze msc_supplies here */
2882 /* create temporay index */
2883
2884 --=============================================
2885 -- NCP:
2886 -- Create index in case of Partial refresh only
2887 -- ============================================
2888 IF MSC_CL_SUPPLY_ODS_LOAD.create_supplies_tmp_ind THEN
2889 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, 'Index creation on Temp Supplies table successful.');
2890 ELSE
2891 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, SQLERRM);
2892 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, 'Index creation on Temp Supplies table failed.');
2893 RAISE SUPPLIES_INDEX_FAIL;
2894 END IF;
2895
2896 msc_analyse_tables_pk.analyse_table( 'SUPPLIES_'||v_instance_code, v_instance_id, -1);
2897
2898 END IF;
2899
2900 COMMIT;
2901
2902 update msc_apps_instances
2903 set SUPPLIES_LOAD_FLAG = G_JOB_DONE
2904 where instance_id = v_instance_id;
2905 commit;
2906
2907 if ( v_coll_prec.wip_flag = MSC_UTIL.SYS_YES ) Then
2908
2909 if (v_is_cont_refresh) Then
2910
2911 if (v_coll_prec.wip_sn_flag = MSC_UTIL.SYS_INCR) then
2912 v_is_incremental_refresh := TRUE;
2913 v_is_partial_refresh := FALSE;
2914 v_exchange_mode := MSC_UTIL.SYS_NO;
2915 elsif (v_coll_prec.wip_sn_flag = MSC_UTIL.SYS_TGT) then
2916 v_is_incremental_refresh := FALSE;
2917 v_is_partial_refresh := TRUE;
2918 v_exchange_mode := MSC_UTIL.SYS_YES;
2919 else
2920 v_is_incremental_refresh := FALSE;
2921 v_is_partial_refresh := FALSE;
2922 v_exchange_mode := MSC_UTIL.SYS_NO;
2923 pSTATUS := OK;
2924 RETURN;
2925 END IF;
2926
2927 END IF;
2928
2929 MSC_CL_WIP_ODS_LOAD.LOAD_JOB_DETAILS;
2930
2931 END IF;
2932
2933 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, 'after job_details.');
2934 ELSIF pTASKNUM= PTASK_SALES_ORDER THEN
2935
2936 IF ( (v_coll_prec.mps_flag = MSC_UTIL.SYS_YES) or
2937 (v_coll_prec.po_flag = MSC_UTIL.SYS_YES) or
2938 (v_coll_prec.oh_flag = MSC_UTIL.SYS_YES) or
2939 (v_coll_prec.wip_flag = MSC_UTIL.SYS_YES) or
2940 (v_coll_prec.supplier_response_flag = MSC_UTIL.SYS_YES) or
2941 (v_coll_prec.user_supply_demand_flag = MSC_UTIL.SYS_YES) ) THEN
2942
2943 -- If any of the supply flags are enabled then wait for supplies to get finished
2944 IF MSC_CL_SUPPLY_ODS_LOAD.IS_SUPPLIES_LOAD_DONE THEN
2945 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, ' Calling MSC_CL_DEMAND_ODS_LOAD.LOAD_SALES_ORDER_2 ...');
2946 FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2947 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LOAD_SALES_ORDER');
2948 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2949 MSC_CL_DEMAND_ODS_LOAD.LOAD_SALES_ORDER;
2950 ELSE
2951 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, 'Loading of Supplies failed.MSC_CL_DEMAND_ODS_LOAD.LOAD_SALES_ORDER');
2952 RAISE SUPPLIES_LOAD_FAIL;
2953 END IF;
2954
2955 ELSE -- no need to wait for supplies
2956 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, ' Calling MSC_CL_DEMAND_ODS_LOAD.LOAD_SALES_ORDER_2 ...');
2957 FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2958 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LOAD_SALES_ORDER');
2959 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2960 MSC_CL_DEMAND_ODS_LOAD.LOAD_SALES_ORDER;
2961 END IF;
2962
2963 IF ( v_is_so_incremental_refresh ) THEN
2964 IF ( v_apps_ver >= MSC_UTIL.G_APPS115 ) THEN
2965
2966 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, ' Calling Linking of Sales Order for 11i source ...');
2967 FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2968 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LINK_SUPP_SO_DEMAND_11I2');
2969 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2970 MSC_CL_DEMAND_ODS_LOAD.LINK_SUPP_SO_DEMAND_11I2;
2971 -- Calling the Linking of external Sales orders for the fix 2353397 --
2972 -- MSC_CL_DEMAND_ODS_LOAD.LINK_SUPP_SO_DEMAND_EXT;
2973
2974 ELSIF ( v_apps_ver = MSC_UTIL.G_APPS110) THEN
2975
2976 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, ' Calling Linking of Sales Order for 110 source ...');
2977 FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2978 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LINK_SUPP_SO_DEMAND_110');
2979 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2980 MSC_CL_DEMAND_ODS_LOAD.LINK_SUPP_SO_DEMAND_110;
2981 END IF;
2982 END IF;
2983
2984 ELSIF pTASKNUM= PTASK_NET_RESOURCE_AVAIL THEN
2985
2986 FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2987 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_RESOURCE_AVAILABILITY.LOAD_NET_RESOURCE_AVAIL');
2988 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2989 MSC_RESOURCE_AVAILABILITY.LOAD_NET_RESOURCE_AVAIL;
2990
2991 ELSIF pTASKNUM= PTASK_UOM THEN
2992
2993 FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
2994 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SETUP_ODS_LOAD.LOAD_UOM');
2995 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
2996 MSC_CL_SETUP_ODS_LOAD.LOAD_UOM;
2997
2998 ELSIF pTASKNUM= PTASK_ATP_RULES THEN
2999
3000 FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
3001 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_ATP_RULES');
3002 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
3003 MSC_CL_OTHER_ODS_LOAD.LOAD_ATP_RULES;
3004
3005 ELSIF pTASKNUM= PTASK_BOR THEN
3006
3007 FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
3008 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_BOM_ODS_LOAD.LOAD_BOR');
3009 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
3010 MSC_CL_BOM_ODS_LOAD.LOAD_BOR;
3011
3012 ELSIF pTASKNUM= PTASK_CALENDAR_DATE THEN
3013
3014 FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
3015 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SETUP_ODS_LOAD.LOAD_CALENDAR_DATE');
3016 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
3017 MSC_CL_SETUP_ODS_LOAD.LOAD_CALENDAR_DATE;
3018
3019 ELSIF pTASKNUM= PTASK_DEMAND_CLASS THEN
3020
3021 FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
3022 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_DEMAND_CLASS');
3023 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
3024 MSC_CL_OTHER_ODS_LOAD.LOAD_DEMAND_CLASS;
3025
3026 ELSIF pTASKNUM= PTASK_DESIGNATOR THEN
3027
3028 FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
3029 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LOAD_DESIGNATOR');
3030 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
3031 MSC_CL_DEMAND_ODS_LOAD.LOAD_DESIGNATOR;
3032
3033 ELSIF pTASKNUM= PTASK_BIS_PFMC_MEASURES THEN
3034
3035 IF v_apps_ver <> MSC_UTIL.G_APPS107 THEN
3036 FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
3037 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_BIS_PFMC_MEASURES');
3038 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
3039 MSC_CL_OTHER_ODS_LOAD.LOAD_BIS_PFMC_MEASURES;
3040 END IF;
3041
3042 ELSIF pTASKNUM= PTASK_BIS_TARGET_LEVELS THEN
3043
3044 IF v_apps_ver <> MSC_UTIL.G_APPS107 THEN
3045 FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
3046 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_BIS_TARGET_LEVELS');
3047 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
3048 MSC_CL_OTHER_ODS_LOAD.LOAD_BIS_TARGET_LEVELS;
3049 END IF;
3050
3051 ELSIF pTASKNUM= PTASK_BIS_TARGETS THEN
3052
3053 IF v_apps_ver <> MSC_UTIL.G_APPS107 THEN
3054 FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
3055 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_BIS_TARGETS');
3056 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
3057 MSC_CL_OTHER_ODS_LOAD.LOAD_BIS_TARGETS;
3058 END IF;
3059
3060 ELSIF pTASKNUM= PTASK_BIS_BUSINESS_PLANS THEN
3061
3062 IF v_apps_ver <> MSC_UTIL.G_APPS107 THEN
3063 FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
3064 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_BIS_BUSINESS_PLANS');
3065 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
3066 MSC_CL_OTHER_ODS_LOAD.LOAD_BIS_BUSINESS_PLANS;
3067 END IF;
3068
3069 ELSIF pTASKNUM= PTASK_BIS_PERIODS THEN
3070
3071 FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
3072 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_BIS_PERIODS');
3073 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
3074 MSC_CL_OTHER_ODS_LOAD.LOAD_BIS_PERIODS;
3075
3076 ELSIF pTASKNUM= PTASK_PARAMETER THEN
3077
3078 FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
3079 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SETUP_ODS_LOAD.LOAD_PARAMETER');
3080 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
3081 MSC_CL_SETUP_ODS_LOAD.LOAD_PARAMETER;
3082
3083 ELSIF pTASKNUM= PTASK_PLANNERS THEN
3084
3085 FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
3086 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_PLANNERS');
3087 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
3088 MSC_CL_OTHER_ODS_LOAD.LOAD_PLANNERS;
3089
3090 ELSIF pTASKNUM= PTASK_PROJECT THEN
3091
3092 FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
3093 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_PROJECT');
3094 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
3095 MSC_CL_OTHER_ODS_LOAD.LOAD_PROJECT;
3096
3097 ELSIF pTASKNUM= PTASK_SUB_INVENTORY THEN
3098
3099 FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
3100 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_SUB_INVENTORY');
3101 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
3102 MSC_CL_OTHER_ODS_LOAD.LOAD_SUB_INVENTORY;
3103
3104 ELSIF pTASKNUM= PTASK_UNIT_NUMBER THEN
3105
3106 FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
3107 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_UNIT_NUMBER');
3108 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
3109 MSC_CL_OTHER_ODS_LOAD.LOAD_UNIT_NUMBER;
3110
3111 ELSIF pTASKNUM = PTASK_ITEM_SUBSTITUTES THEN
3112
3113 IF v_apps_ver <> MSC_UTIL.G_APPS107 THEN
3114 FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
3115 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ITEM_ODS_LOAD.LOAD_ITEM_SUBSTITUTES');
3116 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
3117 MSC_CL_ITEM_ODS_LOAD.LOAD_ITEM_SUBSTITUTES;
3118 END IF;
3119
3120 ELSIF pTASKNUM= PTASK_ITEM_CUSTOMERS THEN
3121
3122 FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
3123 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'TASK_ITEM_CUSTOMERS');
3124 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
3125 MSC_CL_SCE_COLLECTION.LOAD_ITEM_CUSTOMERS(v_instance_id);
3126
3127 ELSIF pTASKNUM= PTASK_COMPANY_USERS THEN
3128
3129 /* Perform this task only if MSC:Configuration is set to
3130 'APS + SCE' or 'SCE. */
3131 IF (MSC_UTIL.G_MSC_CONFIGURATION = MSC_UTIL.G_CONF_APS_SCE
3132 OR MSC_UTIL.G_MSC_CONFIGURATION = MSC_UTIL.G_CONF_SCE) THEN
3133
3134 FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
3135 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SCE_COLLECTION.LOAD_USER_COMPANY');
3136 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
3137 MSC_CL_SCE_COLLECTION.LOAD_USER_COMPANY(v_instance_id);
3138
3139 END IF;
3140 /* SCE Change ends */
3141
3142 ELSIF pTASKNUM= PTASK_TRIP THEN
3143
3144 IF (v_apps_ver >= MSC_UTIL.G_APPS115) OR v_is_legacy_refresh THEN
3145
3146 FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
3147 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_TRIP');
3148 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
3149 MSC_CL_OTHER_ODS_LOAD.LOAD_TRIP;
3150
3151 END IF;
3152
3153 /*ds change start */
3154 ELSIF pTASKNUM = PTASK_RES_INST_REQ THEN
3155 IF MSC_CL_SUPPLY_ODS_LOAD.IS_SUPPLIES_LOAD_DONE THEN
3156 FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
3157 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_WIP_ODS_LOAD.LOAD_RES_INST_REQ');
3158 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
3159 MSC_CL_WIP_ODS_LOAD.LOAD_RES_INST_REQ;
3160 ELSE
3161 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, 'Loading of Supplies failed.PTASK_RES_INST_REQ');
3162 RAISE SUPPLIES_LOAD_FAIL;
3163 END IF;
3164 ELSIF pTASKNUM= PTASK_RESOURCE_SETUP THEN
3165
3166 IF (v_apps_ver >= MSC_UTIL.G_APPS115) OR v_is_legacy_refresh THEN
3167
3168 FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
3169 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_BOM_ODS_LOAD.LOAD_RESOURCE_SETUP');
3170 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
3171 MSC_CL_BOM_ODS_LOAD.LOAD_RESOURCE_SETUP;
3172
3173 END IF;
3174 ELSIF pTASKNUM= PTASK_SETUP_TRANSITION THEN
3175
3176 IF (v_apps_ver >= MSC_UTIL.G_APPS115) OR v_is_legacy_refresh THEN
3177
3178 FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
3179 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_BOM_ODS_LOAD.LOAD_SETUP_TRANSITION');
3180 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
3181 MSC_CL_BOM_ODS_LOAD.LOAD_SETUP_TRANSITION;
3182
3183 END IF;
3184 ELSIF pTASKNUM= PTASK_STD_OP_RESOURCES THEN
3185
3186 IF (v_apps_ver >= MSC_UTIL.G_APPS115) OR v_is_legacy_refresh THEN
3187
3188 FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
3189 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_ROUTING_ODS_LOAD.LOAD_STD_OP_RESOURCES');
3190 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
3191 MSC_CL_ROUTING_ODS_LOAD.LOAD_STD_OP_RESOURCES;
3192
3193 END IF;
3194
3195 /*ds change end */
3196
3197 ELSIF pTASKNUM= PTASK_SALES_CHANNEL THEN
3198
3199 IF (v_apps_ver >= MSC_UTIL.G_APPS115) OR v_is_legacy_refresh THEN -- 7704614
3200 FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
3201 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_SALES_CHANNEL');
3202 -- LOG_MESSAGE(FND_MESSAGE.GET);
3203 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
3204 MSC_CL_OTHER_ODS_LOAD.LOAD_SALES_CHANNEL;
3205 END IF;
3206 ELSIF pTASKNUM= PTASK_FISCAL_CALENDAR THEN
3207
3208 IF (v_apps_ver >= MSC_UTIL.G_APPS115) OR v_is_legacy_refresh THEN -- 7704614
3209 FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
3210 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_FISCAL_CALENDAR');
3211 -- LOG_MESSAGE(FND_MESSAGE.GET);
3212 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
3213 MSC_CL_OTHER_ODS_LOAD.LOAD_FISCAL_CALENDAR;
3214 END IF;
3215 ELSIF pTASKNUM= PTASK_PAYBACK_DEMAND_SUPPLY THEN --bug 5861050
3216
3217 FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
3218 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LOAD_PAYBACK_DEMANDS');
3219 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS,FND_MESSAGE.GET);
3220 MSC_CL_DEMAND_ODS_LOAD.LOAD_PAYBACK_DEMANDS;
3221
3222 FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
3223 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SUPPLY_ODS_LOAD.LOAD_PAYBACK_SUPPLIES');
3224 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS,FND_MESSAGE.GET);
3225 MSC_CL_SUPPLY_ODS_LOAD.LOAD_PAYBACK_SUPPLIES;
3226
3227 ELSIF pTASKNUM= PTASK_DELIVERY_DETAILS THEN
3228 IF (v_apps_ver >= MSC_UTIL.G_APPS120) THEN
3229 FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
3230 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_DELIVERY_DETAILS');
3231 -- LOG_MESSAGE(FND_MESSAGE.GET);
3232 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
3233 MSC_CL_OTHER_ODS_LOAD.LOAD_DELIVERY_DETAILS;
3234 END IF;
3235
3236 ELSIF pTASKNUM= PTASK_CURRENCY_CONVERSION THEN -- for bug # 6469722
3237 FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
3238 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_CURRENCY_CONVERSION');
3239 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
3240
3241 IF (MSC_CL_OTHER_PULL.G_MSC_HUB_CURR_CODE IS NOT NULL) AND (v_apps_ver >= MSC_UTIL.G_APPS115) THEN
3242 MSC_CL_OTHER_ODS_LOAD.LOAD_CURRENCY_CONVERSION;
3243 ELSE
3244 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.');
3245 END IF;
3246
3247 ELSIF pTASKNUM= PTASK_IRO_DEMAND THEN
3248 IF NOT(v_is_cont_refresh) THEN
3249 IF MSC_CL_SUPPLY_ODS_LOAD.IS_SUPPLIES_LOAD_DONE THEN
3250 FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
3251 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_RPO_ODS_LOAD.LOAD_IRO_DEMAND');
3252 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
3253 MSC_CL_RPO_ODS_LOAD.LOAD_IRO_DEMAND;
3254 END IF;
3255 END IF;
3256 ELSIF pTASKNUM= PTASK_ERO_DEMAND THEN
3257 IF NOT(v_is_cont_refresh) THEN
3258 IF MSC_CL_SUPPLY_ODS_LOAD.IS_SUPPLIES_LOAD_DONE THEN
3259 FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
3260 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_RPO_ODS_LOAD.LOAD_ERO_DEMAND');
3261 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
3262 MSC_CL_RPO_ODS_LOAD.LOAD_ERO_DEMAND;
3263 END IF;
3264 END IF;
3265 ELSIF pTASKNUM= PTASK_CMRO THEN
3266
3267 IF (v_apps_ver >= MSC_UTIL.G_APPS121) AND v_is_legacy_refresh THEN
3268 FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
3269 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_VISITS');
3270 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
3271 MSC_CL_OTHER_ODS_LOAD.LOAD_VISITS;
3272 MSC_CL_OTHER_ODS_LOAD.LOAD_MILESTONES;
3273 MSC_CL_OTHER_ODS_LOAD.LOAD_WBS;
3274 MSC_CL_OTHER_ODS_LOAD.LOAD_WOATTRIBUTES;
3275 MSC_CL_OTHER_ODS_LOAD.LOAD_WO_TASK_HIERARCHY;
3276 MSC_CL_OTHER_ODS_LOAD.LOAD_WO_OPERATION_REL;
3277 END IF;
3278
3279
3280 /* usaf */
3281
3282 ELSIF ( pTASKNUM= PTASK_EAM_INFO ) THEN
3283 IF ( v_apps_ver >= MSC_UTIL.G_EAM_CMRO_SUP_VER
3284 AND MSC_UTIL.G_CMRO_EAM_INT_ENABLED = 'Y' ) THEN
3285 FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
3286 FND_MESSAGE.SET_TOKEN('PROCEDURE',
3287 'MSC_CL_EAM_ODS_LOAD.LOAD_EAM_INFO');
3288 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
3289 MSC_CL_EAM_ODS_LOAD.LOAD_EAM_INFO ;
3290 END IF;
3291 ELSIF ( pTASKNUM= PTASK_EAM_FORECAST ) THEN
3292 IF ( v_apps_ver >= MSC_UTIL.G_EAM_CMRO_SUP_VER
3293 AND MSC_UTIL.G_CMRO_EAM_INT_ENABLED = 'Y' ) THEN
3294
3295 IF MSC_CL_SUPPLY_ODS_LOAD.IS_SUPPLIES_LOAD_DONE THEN
3296 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS,
3297 'Loading of Eam forecasts done');
3298 ELSE
3299 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS,
3300 'Loading of Supplies failed.TASK_EAM_FORECASTS');
3301 RAISE SUPPLIES_LOAD_FAIL;
3302 END IF;
3303
3304 END IF;
3305 ELSIF ( pTASKNUM= PTASK_EAM_FORECAST_DEMANDS ) THEN
3306 IF ( v_apps_ver >= MSC_UTIL.G_EAM_CMRO_SUP_VER
3307 AND MSC_UTIL.G_CMRO_EAM_INT_ENABLED = 'Y' ) THEN
3308
3309 IF MSC_CL_SUPPLY_ODS_LOAD.IS_SUPPLIES_LOAD_DONE THEN
3310 FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
3311 FND_MESSAGE.SET_TOKEN('PROCEDURE',
3312 'MSC_CL_EAM_ODS_LOAD.LOAD_EAM_FORECAST_DEMANDS ');
3313 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
3314 MSC_CL_EAM_ODS_LOAD.LOAD_EAM_FORECAST_DEMANDS ;
3315 ELSE
3316 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS,
3317 'Loading of Supplies failed.PTASK_EAM_FORECAST_DEMANDS');
3318 RAISE SUPPLIES_LOAD_FAIL;
3319 END IF;
3320 END IF;
3321 ELSIF ( pTASKNUM= PTASK_EAM_FORECAST_RR ) THEN
3322 IF ( v_apps_ver >= MSC_UTIL.G_EAM_CMRO_SUP_VER
3323 AND MSC_UTIL.G_CMRO_EAM_INT_ENABLED = 'Y' ) THEN
3324
3325 IF MSC_CL_SUPPLY_ODS_LOAD.IS_SUPPLIES_LOAD_DONE THEN
3326 FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
3327 FND_MESSAGE.SET_TOKEN('PROCEDURE',
3328 'MSC_CL_EAM_ODS_LOAD.LOAD_EAM_FORECAST_RR ');
3329 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
3330 MSC_CL_EAM_ODS_LOAD.LOAD_EAM_FORECAST_RR ;
3331 ELSE
3332 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS,
3333 'Loading of Supplies failed.PTASK_EAM_FORECAST_RR');
3334 RAISE SUPPLIES_LOAD_FAIL;
3335 END IF;
3336 --MSC_CL_WIP_ODS_LOAD.LOAD_ODS_RES_REQ;
3337 END IF;
3338
3339 ELSIF ( pTASKNUM= PTASK_VISITS ) THEN
3340 IF ( v_apps_ver >= MSC_UTIL.G_EAM_CMRO_SUP_VER
3341 AND MSC_UTIL.G_CMRO_EAM_INT_ENABLED = 'Y' ) THEN
3342 FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
3343 FND_MESSAGE.SET_TOKEN('PROCEDURE',
3344 'MSC_CL_AHL_ODS_LOAD.TASK_VISITS');
3345 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
3346 MSC_CL_AHL_ODS_LOAD.LOAD_VISITS;
3347 END IF;
3348
3349 ELSIF ( pTASKNUM= PTASK_WO_ATTRIBUTES ) THEN
3350 IF ( v_apps_ver >= MSC_UTIL.G_EAM_CMRO_SUP_VER
3351 AND MSC_UTIL.G_CMRO_EAM_INT_ENABLED = 'Y' ) THEN
3352 FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
3353 FND_MESSAGE.SET_TOKEN('PROCEDURE',
3354 'MSC_CL_AHL_ODS_LOAD.TASK_WO_ATTRIBUTES ');
3355 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
3356 MSC_CL_AHL_ODS_LOAD.LOAD_WO_ATTRIBUTES ;
3357 END IF;
3358
3359 ELSIF ( pTASKNUM= PTASK_WO_TASK_HIERARCHY ) THEN
3360 IF ( v_apps_ver >= MSC_UTIL.G_EAM_CMRO_SUP_VER
3361 AND MSC_UTIL.G_CMRO_EAM_INT_ENABLED = 'Y' ) THEN
3362 FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
3363 FND_MESSAGE.SET_TOKEN('PROCEDURE',
3364 'MSC_CL_AHL_ODS_LOAD.LOAD_WO_TASK_HIERARCHY');
3365 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
3366 MSC_CL_AHL_ODS_LOAD.LOAD_WO_TASK_HIERARCHY;
3367 END IF;
3368
3369 ELSIF ( pTASKNUM= PTASK_WO_OPERATION_REL ) THEN
3370 IF ( v_apps_ver >= MSC_UTIL.G_EAM_CMRO_SUP_VER
3371 AND MSC_UTIL.G_CMRO_EAM_INT_ENABLED = 'Y' ) THEN
3372 FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
3373 FND_MESSAGE.SET_TOKEN('PROCEDURE',
3374 'MSC_CL_AHL_ODS_LOAD.LOAD_WO_OPERATION_REL');
3375 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
3376 MSC_CL_AHL_ODS_LOAD.LOAD_WO_OPERATION_REL ;
3377 END IF;
3378
3379 ELSIF ( pTASKNUM= PTASK_WORK_BREAKDOWN_STRUCT ) THEN
3380 IF ( v_apps_ver >= MSC_UTIL.G_EAM_CMRO_SUP_VER
3381 AND MSC_UTIL.G_CMRO_EAM_INT_ENABLED = 'Y' ) THEN
3382 FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
3383 FND_MESSAGE.SET_TOKEN('PROCEDURE',
3384 'MSC_CL_AHL_ODS_LOAD.LOAD_WORK_BREAKDOWN_STRUCT');
3385 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
3386 MSC_CL_AHL_ODS_LOAD.LOAD_WORK_BREAKDOWN_STRUCT;
3387 END IF;
3388
3389 ELSIF ( pTASKNUM= PTASK_WO_SUB_COMP ) THEN
3390 IF ( v_apps_ver >= MSC_UTIL.G_EAM_CMRO_SUP_VER
3391 AND MSC_UTIL.G_CMRO_EAM_INT_ENABLED = 'Y' ) THEN
3392 FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
3393 FND_MESSAGE.SET_TOKEN('PROCEDURE',
3394 'MSC_CL_AHL_ODS_LOAD.LOAD_WO_SUB_COMP');
3395 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
3396 MSC_CL_AHL_ODS_LOAD.LOAD_WO_SUB_COMP;
3397 END IF;
3398
3399 ELSIF ( pTASKNUM= PTASK_WO_MILESTONES ) THEN
3400 IF ( v_apps_ver >= MSC_UTIL.G_EAM_CMRO_SUP_VER
3401 AND MSC_UTIL.G_CMRO_EAM_INT_ENABLED = 'Y' ) THEN
3402 FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
3403 FND_MESSAGE.SET_TOKEN('PROCEDURE',
3404 'MSC_CL_AHL_ODS_LOAD.LOAD_WO_MILESTONES');
3405 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
3406 MSC_CL_AHL_ODS_LOAD.LOAD_WO_MILESTONES;
3407 END IF;
3408
3409 ELSIF ( pTASKNUM= PTASK_CMRO_FORECAST_DEMANDS ) THEN
3410 IF ( v_apps_ver >= MSC_UTIL.G_EAM_CMRO_SUP_VER
3411 AND MSC_UTIL.G_CMRO_EAM_INT_ENABLED = 'Y' ) THEN
3412
3413 IF MSC_CL_SUPPLY_ODS_LOAD.IS_SUPPLIES_LOAD_DONE THEN
3414 FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
3415 FND_MESSAGE.SET_TOKEN('PROCEDURE',
3416 'MSC_CL_AHL_ODS_LOAD.LOAD_CMRO_FORECAST_DEMANDS ');
3417 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
3418 MSC_CL_AHL_ODS_LOAD.LOAD_CMRO_FORECAST_DEMANDS ;
3419 ELSE
3420 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS,
3421 'Loading of Supplies failed.PTASK_CMRO_FORECAST_DEMANDS');
3422 RAISE SUPPLIES_LOAD_FAIL;
3423 END IF;
3424 END IF;
3425
3426 ELSIF ( pTASKNUM= PTASK_CMRO_FORECAST_RR ) THEN
3427 IF ( v_apps_ver >= MSC_UTIL.G_EAM_CMRO_SUP_VER
3428 AND MSC_UTIL.G_CMRO_EAM_INT_ENABLED = 'Y' ) THEN
3429
3430 IF MSC_CL_SUPPLY_ODS_LOAD.IS_SUPPLIES_LOAD_DONE THEN
3431 FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
3432 FND_MESSAGE.SET_TOKEN('PROCEDURE',
3433 'MSC_CL_AHL_ODS_LOAD.LOAD_CMRO_FORECAST_RR ');
3434 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
3435 MSC_CL_AHL_ODS_LOAD.LOAD_CMRO_FORECAST_RR ;
3436 ELSE
3437 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS,
3438 'Loading of Supplies failed.PTASK_CMRO_FORECAST_RR');
3439 RAISE SUPPLIES_LOAD_FAIL;
3440 END IF;
3441 --MSC_CL_WIP_ODS_LOAD.LOAD_ODS_RES_REQ;
3442 END IF;
3443
3444 ELSIF ( pTASKNUM= PTASK_CMRO_SUPP_RESRV ) THEN
3445 IF ( v_apps_ver >= MSC_UTIL.G_EAM_CMRO_SUP_VER
3446 AND MSC_UTIL.G_CMRO_EAM_INT_ENABLED = 'Y' ) THEN
3447 FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
3448 FND_MESSAGE.SET_TOKEN('PROCEDURE',
3449 'MSC_CL_AHL_ODS_LOAD.LOAD_SUPPLY_RESERVATIONS ');
3450 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
3451 MSC_CL_AHL_ODS_LOAD.LOAD_SUPPLY_RESERVATIONS ;
3452 END IF;
3453 /* usaf*/
3454
3455 ELSIF ( pTASKNUM= PTASK_CMRO_CLOSED_WO ) THEN
3456 IF ( v_apps_ver >= MSC_UTIL.G_EAM_CMRO_SUP_VER
3457 AND MSC_UTIL.G_CMRO_EAM_INT_ENABLED = 'Y' ) THEN
3458 MSC_UTIL.LOG_MSG (MSC_UTIL.G_D_STATUS,'b4 call in BAB');
3459 FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
3460 FND_MESSAGE.SET_TOKEN('PROCEDURE',
3461 'MSC_CL_AHL_ODS_LOAD.LOAD_CLOSED_CMRO_WOS');
3462 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
3463 MSC_CL_AHL_ODS_LOAD.LOAD_CLOSED_CMRO_WOS;
3464 END IF;
3465
3466 ELSIF ( pTASKNUM= PTASK_OSP_SUPPLY ) THEN
3467 MSC_UTIL.LOG_MSG (MSC_UTIL.G_D_STATUS,'in task osp supply');
3468
3469 IF ( v_apps_ver >= MSC_UTIL.G_EAM_CMRO_SUP_VER
3470 AND MSC_UTIL.G_CMRO_EAM_INT_ENABLED = 'Y' ) THEN
3471
3472 IF MSC_CL_SUPPLY_ODS_LOAD.IS_SUPPLIES_LOAD_DONE THEN
3473 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS,
3474 'Loading of OSP supplies done');
3475 ELSE
3476 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS,
3477 'Loading of Supplies failed.TASK_OSP_SUPPLY');
3478 RAISE SUPPLIES_LOAD_FAIL;
3479 END IF;
3480
3481 END IF;
3482
3483 ELSIF pTASKNUM= PTASK_IBUC_HISTORY THEN
3484
3485 IF (v_apps_ver >= MSC_UTIL.G_APPS121 AND MSC_UTIL.G_COLLECT_SRP_PH2_ENABLE = 'Y') THEN
3486 FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
3487 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_IB_CONTRACTS');
3488 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
3489 MSC_CL_OTHER_ODS_LOAD.LOAD_IB_CONTRACTS;
3490 END IF;
3491
3492 ELSIF pTASKNUM= PTASK_SHORT_TEXT THEN
3493
3494 IF (v_apps_ver >= MSC_UTIL.G_APPS121 AND MSC_UTIL.G_COLLECT_SRP_PH2_ENABLE = 'Y') THEN
3495 FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
3496 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_SHORT_TEXT');
3497 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
3498 MSC_CL_OTHER_ODS_LOAD.LOAD_SHORT_TEXT;
3499 END IF;
3500
3501 ELSIF pTASKNUM= PTASK_LONG_TEXT THEN
3502 IF (v_apps_ver >= MSC_UTIL.G_APPS121 AND MSC_UTIL.G_COLLECT_SRP_PH2_ENABLE = 'Y') THEN
3503 FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
3504 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_OTHER_ODS_LOAD.LOAD_LONG_TEXT');
3505 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
3506 MSC_CL_OTHER_ODS_LOAD.LOAD_LONG_TEXT;
3507 END IF;
3508 ELSE
3509 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, 'Loading of Supplies failed.TASK_WIP_COMP_DEMAND');
3510 RAISE SUPPLIES_LOAD_FAIL;
3511 END IF;
3512
3513
3514 -- ======== If no EXCEPTION occurs, then returns with status = OK =========
3515 --agmcont:
3516 if (v_is_cont_refresh) then
3517 v_is_incremental_refresh := FALSE;
3518 v_is_partial_refresh := FALSE;
3519 end if;
3520
3521 pSTATUS := OK;
3522
3523 FND_MESSAGE.SET_NAME('MSC', 'MSC_ELAPSED_TIME');
3524 FND_MESSAGE.SET_TOKEN('ELAPSED_TIME',
3525 TO_CHAR(CEIL((SYSDATE- lv_task_start_time)*14400.0)/10));
3526 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
3527
3528 msc_util.print_top_wait(CEIL((SYSDATE- lv_task_start_time)*14400.0)/10);
3529 msc_util.print_cum_stat(CEIL((SYSDATE- lv_task_start_time)*14400.0)/10);
3530 msc_util.print_bad_sqls(CEIL((SYSDATE- lv_task_start_time)*14400.0)/10);
3531
3532
3533 EXCEPTION
3534
3535 WHEN SUPPLIES_LOAD_FAIL THEN
3536 ROLLBACK;
3537 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, SQLERRM);
3538 RAISE;
3539
3540 WHEN SUPPLIES_INDEX_FAIL THEN
3541 ROLLBACK;
3542 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, SQLERRM);
3543 RAISE;
3544
3545 WHEN others THEN
3546
3547 -- ============= Raise the EXCEPTION ==============
3548 IF SQLCODE IN (-01578,-26040) THEN
3549 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR,SQLERRM);
3550 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR,'To rectify this problem -');
3551 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR,'Run concurrent program "Truncate Planning Staging Tables" ');
3552 END IF;
3553 --ROLLBACK WORK TO SAVEPOINT ExecuteTask;
3554 ROLLBACK;
3555
3556 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, SQLERRM);
3557
3558 RAISE;
3559
3560 END EXECUTE_PARTIAL_TASK;
3561
3562
3563 /*************** PREPLACE CHANGE END *****************/
3564
3565
3566
3567
3568 /* procedure LOAD_CALENDAR_SET_UP has been moved to package MSC_CL_SETUP_ODS_LOAD
3569 through bug5952569 */
3570
3571 /* procedure LOAD_CALENDAR_DATE has been moved to package MSC_CL_SETUP_ODS_LOAD
3572 through bug5952569 */
3573
3574 /*ds change change start */
3575
3576
3577
3578 --=================== COLLECT CATEGORIES =====================================
3579 --= 1. Category Sets are collected in the Key_Transformation Procedure
3580
3581
3582
3583 -- =========== Public Procedures ===============
3584
3585 /* purge the staging tables
3586 it should be launched as a concurrent program */
3587 PROCEDURE PURGE_STAGING_TABLES( ERRBUF OUT NOCOPY VARCHAR2,
3588 RETCODE OUT NOCOPY NUMBER,
3589 pINSTANCE_ID IN NUMBER,
3590 pVALIDATION IN NUMBER)
3591 IS
3592 BEGIN
3593
3594 SELECT APPS_VER,
3595 SYSDATE,
3596 FND_GLOBAL.USER_ID,
3597 SYSDATE,
3598 FND_GLOBAL.USER_ID
3599 INTO v_apps_ver,
3600 v_current_date,
3601 v_current_user,
3602 v_current_date,
3603 v_current_user
3604 FROM MSC_APPS_INSTANCES
3605 WHERE INSTANCE_ID= pINSTANCE_ID;
3606
3607 IF pVALIDATION= MSC_UTIL.SYS_YES THEN
3608
3609 IF SET_ST_STATUS( ERRBUF, RETCODE,
3610 pINSTANCE_ID, MSC_UTIL.G_ST_PURGING) THEN
3611 COMMIT;
3612 ELSE
3613 ROLLBACK;
3614 RETURN;
3615 END IF;
3616
3617 END IF;
3618
3619 MSC_CL_PURGE_STAGING.PURGE_STAGING_TABLES_SUB( pINSTANCE_ID);
3620
3621 IF SET_ST_STATUS( ERRBUF, RETCODE, pINSTANCE_ID, MSC_UTIL.G_ST_EMPTY) THEN
3622
3623 COMMIT;
3624
3625 END IF;
3626
3627 END PURGE_STAGING_TABLES;
3628
3629 PROCEDURE PURGE_STAGING_TABLES_SUB( p_instance_id IN NUMBER)
3630 IS
3631 BEGIN
3632 MSC_CL_PURGE_STAGING.PURGE_STAGING_TABLES_SUB( p_instance_id);
3633 END PURGE_STAGING_TABLES_SUB;
3634
3635
3636 PROCEDURE LAUNCH_WORKER( ERRBUF OUT NOCOPY VARCHAR2,
3637 RETCODE OUT NOCOPY NUMBER,
3638 pMONITOR_REQUEST_ID IN NUMBER,
3639 pINSTANCE_ID IN NUMBER,
3640 pLCID IN NUMBER,
3641 pTIMEOUT IN NUMBER,
3642 pRECALC_NRA IN NUMBER,
3643 pRECALC_SH IN NUMBER,
3644 pEXCHANGE_MODE IN NUMBER,
3645 pSO_EXCHANGE_MODE IN NUMBER )
3646
3647 IS
3648
3649 ----- TASK CONTROL --------------------------------------------------
3650
3651 lv_task_number PLS_INTEGER; -- NEGATIVE: Unknown Error Occurs
3652 -- 0 : All Task Is Done
3653 -- POSITIVE: The Task Number
3654
3655 lv_task_status NUMBER; -- ::OK : THE TASK IS Done in MSC
3656 -- OTHERS : THE TASK Fails
3657
3658 lv_process_time NUMBER;
3659
3660 EX_PROCESS_TIME_OUT EXCEPTION;
3661
3662 ------ PIPE CONTROL ----------------------------------------------
3663
3664 lv_pipe_ret_code NUMBER; -- The return value of Sending/Receiving Pipe Messages
3665
3666 EX_PIPE_RCV EXCEPTION;
3667 EX_PIPE_SND EXCEPTION;
3668 EXCHG_PRT_ERROR EXCEPTION;
3669
3670
3671 --Status of worker
3672 lv_is_waiting boolean := TRUE;
3673
3674
3675 BEGIN
3676
3677 p_TIMEOUT := pTIMEOUT;
3678 v_monitor_request_id := pMONITOR_REQUEST_ID;
3679
3680 --PBS := TO_NUMBER( FND_PROFILE.VALUE('MRP_PURGE_BATCH_SIZE'));
3681
3682 FND_MESSAGE.SET_NAME('MSC','MSC_CL_PURGE_BATCH_SIZE');
3683 FND_MESSAGE.SET_TOKEN('PBS',PBS);
3684 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
3685
3686 IF fnd_global.conc_request_id > 0 THEN
3687 v_cp_enabled:= MSC_UTIL.SYS_YES;
3688 ELSE
3689 v_cp_enabled:= MSC_UTIL.SYS_NO;
3690 END IF;
3691
3692 v_recalc_nra := pRECALC_NRA;
3693 v_recalc_sh := pRECALC_SH;
3694 v_exchange_mode := pEXCHANGE_MODE;
3695 v_so_exchange_mode := pSO_EXCHANGE_MODE;
3696
3697 v_prec_defined := FALSE;
3698
3699 MSC_CL_SETUP_ODS_LOAD.GET_COLL_PARAM (pINSTANCE_ID); /* cursor org requires the org group flag */
3700
3701 -- to initialize common global variables bug#5897346
3702 MSC_UTIL.INITIALIZE_COMMON_GLOBALS( pINSTANCE_ID);
3703
3704 INITIALIZE_LOAD_GLOBALS( pINSTANCE_ID);
3705
3706 -- agmcont:
3707 if (v_is_cont_refresh ) then
3708 select lcid
3709 INTO v_last_collection_id
3710 from msc_apps_instances
3711 where instance_id = pINSTANCE_ID;
3712 else
3713 v_last_collection_id:= pLCID;
3714 end if;
3715
3716 LOOP
3717
3718 EXIT WHEN is_monitor_status_running <> MSC_UTIL.SYS_YES;
3719
3720 EXIT WHEN is_request_status_running <> MSC_UTIL.SYS_YES;
3721
3722 -- ============= Check the execution time ==============
3723
3724 select (SYSDATE- START_TIME) into lv_process_time from dual;
3725 IF lv_process_time > pTIMEOUT/1440.0 THEN Raise EX_PROCESS_TIME_OUT;
3726 END IF;
3727
3728 -- ============= Get the Task from Task Que ==============
3729
3730 lv_pipe_ret_code := DBMS_PIPE.RECEIVE_MESSAGE( v_pipe_task_que, PIPE_TIME_OUT);
3731
3732 FND_MESSAGE.SET_NAME('MSC','MSC_CL_WORKER_RCV_RET_CODE');
3733 FND_MESSAGE.SET_TOKEN('LV_TASK_NUMBER',lv_pipe_ret_code);
3734 MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, FND_MESSAGE.GET);
3735
3736
3737 IF lv_pipe_ret_code<>0 THEN
3738
3739 IF lv_pipe_ret_code = 1 THEN
3740 IF lv_is_waiting THEN
3741 lv_is_waiting := false;
3742 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS,'Waiting for task to arrive');
3743 END IF;
3744 ELSE
3745 RAISE EX_PIPE_RCV;
3746 END IF;
3747
3748 ELSE
3749 lv_is_waiting := true;
3750 DBMS_PIPE.UNPACK_MESSAGE( lv_task_number);
3751
3752 FND_MESSAGE.SET_NAME('MSC','MSC_CL_WORKER_TSK_UNPACK');
3753 FND_MESSAGE.SET_TOKEN('LV_TASK_NUM',lv_task_number);
3754 MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, FND_MESSAGE.GET);
3755
3756 EXIT WHEN lv_task_number<= 0; -- No task is left or unknown error occurs.
3757
3758 -- ============= Execute the Task =============
3759
3760 lv_task_status := FAIL;
3761
3762 /** PREPLACE CHANGE START **/
3763
3764 --=====================================
3765 -- NCPerf.
3766 -- Call EXECUTE_PARTIAL_TASK in case of
3767 -- Partial and Net Change collections.
3768 -- ====================================
3769
3770 -- agmcont
3771 --EXECUTE_TASK( lv_task_status, lv_task_number);
3772 IF (v_is_partial_refresh or v_is_incremental_refresh or
3773 v_is_cont_refresh or (v_coll_prec.ds_mode = MSC_UTIL.SYS_YES) ) THEN
3774 MSC_CL_SETUP_ODS_LOAD.GET_COLL_PARAM (pINSTANCE_ID);
3775
3776 MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'Calling Execute Partial Task for task number: '||lv_task_number);
3777 EXECUTE_PARTIAL_TASK( lv_task_status, lv_task_number,
3778 v_coll_prec);
3779 ELSE
3780
3781 MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'Calling Execute Task for task number: '||lv_task_number);
3782 EXECUTE_TASK( lv_task_status, lv_task_number);
3783 END IF;
3784
3785 /** PREPLACE CHANGE END **/
3786
3787 IF lv_task_status <> OK THEN
3788 FND_MESSAGE.SET_NAME('MSC','MSC_CL_EXECUTE_TSK_PROB');
3789 FND_MESSAGE.SET_TOKEN('LV_TASK_NUMBER',lv_task_number);
3790 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
3791
3792 DBMS_PIPE.PACK_MESSAGE( -lv_task_number);
3793 IF (MSC_UTIL.G_MSC_DEBUG <> 'N' ) THEN
3794 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, 'Sent status '||lv_task_number||' to the monitor.');
3795 END IF;
3796 ELSE
3797
3798 DBMS_PIPE.PACK_MESSAGE( lv_task_number);
3799
3800 IF (MSC_UTIL.G_MSC_DEBUG <> 'N' ) THEN
3801 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, 'Sent status '||lv_task_number||' to the monitor.');
3802 END IF;
3803
3804 END IF;
3805
3806 IF DBMS_PIPE.SEND_MESSAGE( v_pipe_wm)<>0 THEN
3807 RAISE EX_PIPE_SND;
3808 END IF;
3809
3810 IF lv_task_status <> OK THEN
3811 DBMS_LOCK.SLEEP( 2);
3812 END IF;
3813
3814 END IF;
3815
3816 END LOOP;
3817
3818 IF lv_task_number = 0 THEN
3819 COMMIT;
3820
3821 DBMS_PIPE.PACK_MESSAGE( MSC_UTIL.SYS_YES);
3822
3823 IF DBMS_PIPE.SEND_MESSAGE( v_pipe_status)<>0 THEN
3824 RAISE EX_PIPE_SND;
3825 END IF;
3826
3827 FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_SUCCEED');
3828 ERRBUF:= FND_MESSAGE.GET;
3829 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, ERRBUF);
3830
3831 IF v_warning_flag=MSC_UTIL.SYS_YES THEN
3832 RETCODE:= MSC_UTIL.G_WARNING;
3833 ELSE
3834 RETCODE := MSC_UTIL.G_SUCCESS ;
3835 END IF;
3836
3837 ELSE -- unknown error occurs
3838 ROLLBACK;
3839
3840 FND_MESSAGE.SET_NAME('MSC','MSC_CL_UNKNOWN_WORKER_ERR');
3841 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
3842
3843 DBMS_PIPE.PACK_MESSAGE( MSC_UTIL.SYS_YES);
3844
3845 IF DBMS_PIPE.SEND_MESSAGE( v_pipe_status)<>0 THEN
3846 RAISE EX_PIPE_SND;
3847 END IF;
3848
3849 FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_FAIL');
3850 ERRBUF:= FND_MESSAGE.GET;
3851 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, ERRBUF);
3852
3853 RETCODE := MSC_UTIL.G_ERROR;
3854
3855 END IF;
3856
3857 EXCEPTION
3858
3859 WHEN OTHERS THEN
3860
3861 ROLLBACK;
3862
3863 ERRBUF := SQLERRM;
3864 RETCODE := MSC_UTIL.G_ERROR;
3865
3866 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, SQLERRM);
3867
3868
3869 -- send a message of 'unresolavable error' to monitor
3870 DBMS_PIPE.PACK_MESSAGE( UNRESOVLABLE_ERROR);
3871 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, 'Sending message :'||UNRESOVLABLE_ERROR||' to monitor.');
3872
3873 IF DBMS_PIPE.SEND_MESSAGE( v_pipe_wm)<>0 THEN
3874 FND_MESSAGE.SET_NAME('MSC', 'MSC_MSG_SEND_FAIL');
3875 FND_MESSAGE.SET_TOKEN('PIPE', v_pipe_wm);
3876 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
3877 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, 'FAIL TO SEND MESSAGE!');
3878 END IF;
3879
3880 -- send a message of 'the worker ends its process' to monitor
3881 DBMS_PIPE.PACK_MESSAGE( MSC_UTIL.SYS_YES);
3882
3883 IF DBMS_PIPE.SEND_MESSAGE( v_pipe_status)<>0 THEN
3884 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, 'FAIL TO SEND MESSAGE!');
3885 END IF;
3886
3887 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, 'Error_Stack...' );
3888 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, DBMS_UTILITY.FORMAT_ERROR_STACK );
3889 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, 'Error_Backtrace...' );
3890 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, DBMS_UTILITY.FORMAT_ERROR_BACKTRACE );
3891
3892 END LAUNCH_WORKER;
3893
3894 -- ===============================================================
3895
3896
3897 PROCEDURE LAUNCH_MONITOR( ERRBUF OUT NOCOPY VARCHAR2,
3898 RETCODE OUT NOCOPY NUMBER,
3899 pINSTANCE_ID IN NUMBER,
3900 pTIMEOUT IN NUMBER,
3901 pTotalWorkerNum IN NUMBER,
3902 pRECALC_NRA IN NUMBER,
3903 pRECALC_SH IN NUMBER,
3904 pPURGE_SH IN NUMBER, --to delete the Sourcing History, default is no
3905 pAPCC_refresh IN NUMBER DEFAULT MSC_UTIL.SYS_NO) -- to refresh APCC data
3906
3907 IS
3908
3909 lc_i PLS_INTEGER;
3910 lv_task_number NUMBER;
3911 lv_task_not_completed NUMBER := 0;
3912
3913 lv_process_time NUMBER;
3914
3915 lv_bon_start_end NUMBER; -- bug 9194726
3916
3917 EX_PIPE_RCV EXCEPTION;
3918 EX_PIPE_SND EXCEPTION;
3919 EX_PROCESS_TIME_OUT EXCEPTION;
3920
3921 lv_pipe_ret_code NUMBER;
3922
3923 lv_check_point NUMBER := 0;
3924
3925 lvs_request_id NumTblTyp := NumTblTyp(0);
3926
3927 lv_worker_committed NUMBER;
3928
3929 lv_delete_flag NUMBER;
3930
3931 lv_start_time DATE;
3932
3933 lv_collection_plan_exists NUMBER;
3934
3935 lv_total_task_number NUMBER:= TOTAL_TASK_NUMBER;
3936
3937 lv_sql_stmt VARCHAR2(5000);
3938
3939 lv_dblink VARCHAR2(128);
3940
3941 lv_ret_res_ava NUMBER ;
3942
3943 lv_po_flag NUMBER;
3944
3945 lv_sales_order_flag NUMBER;
3946
3947 /*ATP SUMMARY CHANGES */
3948 lv_atp_request_id number;
3949 lv_atp_request_id1 number;
3950 lv_atp_package_exists number;
3951 lv_inv_ctp number;
3952 lv_MSC_ENABLE_ATP_SUMMARY number;
3953
3954 lv_debug_ret number;
3955
3956 lv_apps_schema varchar2(32);
3957 lv_read_only_flag varchar2(32);
3958
3959 lv_pRECALC_NRA_NEW NUMBER;/*5896618*/
3960
3961
3962 CURSOR c_query_package is
3963 SELECT 1
3964 FROM ALL_SOURCE
3965 WHERE NAME = 'MSC_POST_PRO'
3966 AND TYPE = 'PACKAGE BODY'
3967 AND OWNER = lv_apps_schema
3968 AND ROWNUM<2;
3969
3970
3971 /* SCE change starts */
3972 lv_sce_pub_req_id NUMBER;
3973 lv_process_comp_err NUMBER;
3974 /* SCE change ends */
3975 total_task NUMBER;
3976 l_req_id NUMBER;
3977
3978
3979
3980 BEGIN
3981 p_TIMEOUT := pTIMEOUT;
3982 msc_util.print_ods_params(pRECALC_SH,pPURGE_SH);
3983 /*5896618*/
3984 Select decode(nra,2,2,1) into lv_pRECALC_NRA_NEW from msc_coll_parameters
3985 where instance_id = pINSTANCE_ID;
3986 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS,'Recalculate NRA : '||lv_pRECALC_NRA_NEW);
3987 /*5896618*/
3988 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS,'Monitor running in dsMode= '||to_char(v_DSMode));
3989
3990 lv_read_only_flag:='U';
3991 BEGIN
3992 select oracle_username
3993 into lv_apps_schema
3994 from fnd_oracle_userid where
3995 read_only_flag = lv_read_only_flag;
3996 EXCEPTION
3997 WHEN OTHERS THEN
3998 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, SQLERRM);
3999 END;
4000
4001 IF fnd_global.conc_request_id > 0 THEN
4002 v_cp_enabled:= MSC_UTIL.SYS_YES;
4003 ELSE
4004 v_cp_enabled:= MSC_UTIL.SYS_NO;
4005 END IF;
4006
4007 v_prec_defined := FALSE;
4008
4009 MSC_CL_SETUP_ODS_LOAD.GET_COLL_PARAM (pINSTANCE_ID); /* cursor org requires the org group flag */
4010 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS,'Monitor running in DSMODE = '||to_char(v_coll_prec.ds_mode));
4011
4012 -- to initialize common global variables bug#5897346
4013 MSC_UTIL.INITIALIZE_COMMON_GLOBALS( pINSTANCE_ID);
4014
4015 INITIALIZE_LOAD_GLOBALS( pINSTANCE_ID);
4016
4017 BEGIN
4018 select po, sales_order
4019 into lv_po_flag, lv_sales_order_flag
4020 from msc_coll_parameters
4021 where instance_id=pINSTANCE_ID;
4022 END;
4023
4024 v_req_ext_po_so_linking := FALSE;
4025 IF ( lv_po_flag = MSC_UTIL.SYS_YES OR
4026 NOT ((v_is_partial_refresh and lv_sales_order_flag = MSC_UTIL.SYS_NO) OR (v_is_cont_refresh and lv_sales_order_flag = MSC_UTIL.SYS_NO))) Then
4027 v_req_ext_po_so_linking := TRUE;
4028 END IF;
4029
4030 BEGIN
4031 SELECT MSC_UTIL.SYS_YES
4032 INTO lv_collection_plan_exists
4033 FROM MSC_PLANS
4034 WHERE PLAN_ID= -1;
4035 EXCEPTION
4036
4037 WHEN NO_DATA_FOUND THEN
4038
4039 INSERT INTO MSC_PLANS
4040 ( PLAN_ID,
4041 COMPILE_DESIGNATOR,
4042 SR_INSTANCE_ID,
4043 CURR_APPEND_PLANNED_ORDERS,
4044 CURR_CUTOFF_DATE,
4045 CURR_DEMAND_TIME_FENCE_FLAG,
4046 CURR_OPERATION_SCHEDULE_TYPE,
4047 CURR_OVERWRITE_OPTION,
4048 CURR_PLANNING_TIME_FENCE_FLAG,
4049 CURR_PLAN_TYPE,
4050 CURR_START_DATE,
4051 DAILY_CUTOFF_BUCKET,
4052 DAILY_ITEM_AGGREGATION_LEVEL,
4053 DAILY_MATERIAL_CONSTRAINTS,
4054 DAILY_RESOURCE_CONSTRAINTS,
4055 DAILY_RES_AGGREGATION_LEVEL,
4056 ORGANIZATION_ID,
4057 WEEKLY_CUTOFF_BUCKET,
4058 WEEKLY_ITEM_AGGREGATION_LEVEL,
4059 WEEKLY_MATERIAL_CONSTRAINTS,
4060 WEEKLY_RESOURCE_CONSTRAINTS,
4061 WEEKLY_RES_AGGREGATION_LEVEL,
4062 OPTIMIZE_FLAG,
4063 SCHEDULE_FLAG,
4064 CURR_ENFORCE_DEM_DUE_DATES,
4065 CURR_PLANNED_RESOURCES,
4066 DAILY_RTG_AGGREGATION_LEVEL,
4067 WEEKLY_RTG_AGGREGATION_LEVEL,
4068 PERIOD_CUTOFF_BUCKET,
4069 PERIOD_MATERIAL_CONSTRAINTS,
4070 PERIOD_RESOURCE_CONSTRAINTS,
4071 PERIOD_ITEM_AGGREGATION_LEVEL,
4072 PERIOD_RES_AGGREGATION_LEVEL,
4073 LAST_UPDATE_DATE,
4074 LAST_UPDATED_BY,
4075 CREATION_DATE,
4076 CREATED_BY )
4077 VALUES
4078 ( -1,
4079 'Collection',
4080 v_instance_id,
4081 1,
4082 v_current_date,
4083 1,
4084 1,
4085 1,
4086 1,
4087 1,
4088 v_current_date,
4089 1,
4090 1,
4091 1,
4092 1,
4093 1,
4094 -1,
4095 1,
4096 1,
4097 1,
4098 1,
4099 1,
4100 1,
4101 1,
4102 1,
4103 1,
4104 1,
4105 1,
4106 1,
4107 1,
4108 1,
4109 1,
4110 1,
4111 v_current_date,
4112 v_current_user,
4113 v_current_date,
4114 v_current_user);
4115
4116 WHEN OTHERS THEN
4117 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, SQLERRM);
4118 RAISE;
4119 END;
4120
4121 lv_check_point:= 1;
4122
4123 IF SET_ST_STATUS( ERRBUF, RETCODE, pINSTANCE_ID, MSC_UTIL.G_ST_COLLECTING) THEN
4124
4125 COMMIT;
4126 lv_check_point:= 2;
4127 ELSE
4128 ROLLBACK;
4129 RETURN;
4130 END IF;
4131
4132 DBMS_PIPE.PURGE( v_pipe_task_que);
4133 DBMS_PIPE.PURGE( v_pipe_wm);
4134 DBMS_PIPE.PURGE( v_pipe_mw);
4135 DBMS_PIPE.PURGE( v_pipe_status);
4136
4137 --- PREPLACE CHANGE START ---
4138 IF (v_is_partial_refresh OR v_is_cont_refresh) THEN
4139
4140 /* added this piece of code for Bug: 2015868, the recalculation of Resource availability and
4141 Sourcing history needs to be set in Planning ODS load only, for Partial Refresh
4142 It will behave same as in complete refresh coll*/
4143
4144 update msc_coll_parameters
4145 set SOURCING_HISTORY = pRECALC_SH
4146 where instance_id = pINSTANCE_ID;
4147
4148 --MSC_CL_SETUP_ODS_LOAD.GET_COLL_PARAM (pINSTANCE_ID); /* calling above */
4149 END IF;
4150
4151 /* CP changes start */
4152 /* Find out the MSC:Configuration profile option value. */
4153
4154 MSC_UTIL.G_MSC_CONFIGURATION := nvl(fnd_profile.value('MSC_X_CONFIGURATION'), MSC_UTIL.G_CONF_APS);
4155
4156 /* Put configuration related information in LOG file */
4157
4158 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, 'The MSC : Configuration profile option : '||MSC_UTIL.G_MSC_CONFIGURATION);
4159 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, 'Responsibility_id = '||NVL(FND_GLOBAL.RESP_ID,-99));
4160 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, 'Application_id = '||NVL(FND_GLOBAL.RESP_APPL_ID, -99));
4161
4162 /* CP changes end */
4163
4164 --agmcont:
4165
4166 --===========================================
4167 -- NCPerf.
4168 -- Call LAUNCH_MON_PARTIAL in case of
4169 -- Partial and Net Change refresh collections
4170 -- ==========================================
4171
4172 IF (v_is_partial_refresh or v_is_incremental_refresh
4173 or v_is_cont_refresh) THEN
4174 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, 'calling LAUNCH_MON_PARTIAL');
4175 LAUNCH_MON_PARTIAL(
4176 ERRBUF ,
4177 RETCODE ,
4178 pINSTANCE_ID ,
4179 pTIMEOUT ,
4180 pTotalWorkerNum ,
4181 lv_pRECALC_NRA_NEW ,
4182 pRECALC_SH ,
4183 pPURGE_SH ,
4184 pAPCC_refresh
4185 );
4186 RETURN;
4187 END IF;
4188
4189 --- PREPLACE CHANGE END ---
4190
4191 -- ============== Create Temproray Tables ====================
4192 v_exchange_mode:= MSC_UTIL.SYS_NO;
4193 v_so_exchange_mode:= MSC_UTIL.SYS_NO;
4194
4195 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, 'check4 ');
4196 IF v_is_complete_refresh AND is_msctbl_partitioned('MSC_SYSTEM_ITEMS') THEN
4197 IF MSC_CL_EXCHANGE_PARTTBL.Initialize( v_instance_id,
4198 v_instance_code,
4199 v_is_so_complete_refresh) THEN
4200 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, 'Initialized');
4201 IF MSC_CL_EXCHANGE_PARTTBL.Create_Temp_Tbl THEN
4202 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, ' CREATE TEMP TABLES DONE ');
4203 v_exchange_mode:= MSC_UTIL.SYS_YES;
4204
4205 IF v_is_so_complete_refresh THEN
4206 v_so_exchange_mode:= MSC_UTIL.SYS_YES;
4207 END IF;
4208 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, ' Exchange Mode = '||v_exchange_mode);
4209 ELSE
4210 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, 'Create_Temp_Tbl failed');
4211 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, ERRBUF);
4212 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, SQLERRM);
4213
4214 RETCODE := MSC_UTIL.G_ERROR;
4215
4216 RETURN;
4217
4218 END IF; -- end Create_Temp_Tbl
4219
4220 ELSE
4221 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, ERRBUF);
4222 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, SQLERRM);
4223
4224 RETCODE := MSC_UTIL.G_ERROR;
4225
4226 RETURN;
4227
4228 END IF; -- initialization
4229
4230 END IF; -- complete refresh and partitioned
4231
4232 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, 'CREATE PARTITIONS DONE');
4233
4234 /* SCE CHANGE starts*/
4235
4236 -- =============================================
4237 -- Change the company name in msc_companies and
4238 -- msc_trading_partners if it is changed in
4239 -- MSC : Operator Company Name profile option.
4240 -- =============================================
4241
4242
4243 IF (MSC_UTIL.G_MSC_CONFIGURATION = MSC_UTIL.G_CONF_APS_SCE
4244 OR MSC_UTIL.G_MSC_CONFIGURATION = MSC_UTIL.G_CONF_SCE) THEN
4245 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, 'before PROCESS_COMPANY_CHANGE');
4246 MSC_CL_SCE_COLLECTION.PROCESS_COMPANY_CHANGE(lv_process_comp_err);
4247
4248 if (lv_process_comp_err = MSC_UTIL.G_ERROR) THEN
4249 ROLLBACK;
4250 RETCODE := MSC_UTIL.G_ERROR;
4251 RETURN;
4252 end if;
4253
4254 END IF;
4255
4256 -- ========== Get My Company Name ============
4257 --IF (G_MSC_CONFIGURATION = G_CONF_APS_SCE OR G_MSC_CONFIGURATION = MSC_UTIL.G_CONF_SCE) THEN
4258 v_my_company_name := MSC_CL_SCE_COLLECTION.GET_MY_COMPANY;
4259
4260 IF (v_my_company_name = null) then
4261 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, 'Error while fetching Company Name');
4262 ROLLBACK;
4263 RETCODE := MSC_UTIL.G_ERROR;
4264 RETURN;
4265 END IF;
4266 --END IF;
4267
4268 -- ========= Get the parameter value ========
4269 /* SCE CHANGE ends*/
4270
4271 -- =========== Data Cleansing =================
4272
4273 /* SCE Debug */
4274 FND_MESSAGE.SET_NAME('MSC', 'MSC_X_SHOW_CONFIG');
4275 FND_MESSAGE.SET_TOKEN('NAME', MSC_UTIL.G_MSC_CONFIGURATION);
4276 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
4277
4278 FND_MESSAGE.SET_NAME('MSC', 'MSC_X_SHOW_COMPANY');
4279 FND_MESSAGE.SET_TOKEN('NAME', v_my_company_name);
4280 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
4281
4282 /* Following step does the data cleanup in staging tables and creates
4283 global Ids for Trading Partner and Items.
4284
4285 If MSC:Configuration = 'APS' then
4286 - Execute MSC_CL_SETUP_ODS_LOAD.CLEANSE_DATA (Hook for Customization)
4287 - TRANSFORM KEYS
4288
4289 If MSC:Configuration = 'APS+SCE' or 'SCE' then
4290 - Execute MSC_CL_SETUP_ODS_LOAD.CLEANSE_DATA (Hook for Customization)
4291 - MSC_CL_SCE_COLLECTION.CLEANSE_DATA_FOR_SCE (Data cleanup for Multi Company)
4292 - MSC_CL_SCE_COLLECTION.SCE_TRANSFORM_KEYS (New Companies and Sites in Collaboration area)
4293 - TRANSFORM KEYS (Global Ids for Trading Partners in Planning Area)
4294 */
4295
4296 /* DEBUG */
4297 if v_is_incremental_refresh THEN MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, 'Incremental Refresh'); end if;
4298
4299 IF (MSC_UTIL.G_MSC_CONFIGURATION = MSC_UTIL.G_CONF_APS_SCE OR MSC_UTIL.G_MSC_CONFIGURATION = MSC_UTIL.G_CONF_SCE) THEN
4300 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, 'before MSC_CL_SETUP_ODS_LOAD.CLEANSE_DATA 1');
4301 IF MSC_CL_SETUP_ODS_LOAD.CLEANSE_DATA
4302 /* SCE CHANGE starts */
4303 /* Data cleanup based on MSC:Configuration profile option */
4304 AND MSC_CL_SCE_COLLECTION.CLEANSE_DATA_FOR_SCE(v_instance_id,
4305 v_my_company_name)
4306 AND MSC_CL_SCE_COLLECTION.SCE_TRANSFORM_KEYS(v_instance_id,
4307 v_current_user,
4308 v_current_date,
4309 v_last_collection_id,
4310 v_is_incremental_refresh,
4311 v_is_complete_refresh,
4312 v_is_partial_refresh,
4313 v_is_cont_refresh,
4314 v_coll_prec.tp_vendor_flag,
4315 v_coll_prec.tp_customer_flag)
4316
4317 /* SCE CHANGE ends */
4318
4319 AND MSC_CL_SETUP_ODS_LOAD.TRANSFORM_KEYS THEN
4320
4321 COMMIT;
4322
4323
4324 ELSE
4325
4326 ROLLBACK;
4327
4328 FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_DC_FAIL');
4329 ERRBUF:= FND_MESSAGE.GET;
4330
4331 IF SET_ST_STATUS( ERRBUF, RETCODE, pINSTANCE_ID, MSC_UTIL.G_ST_READY) THEN
4332 COMMIT;
4333 END IF;
4334
4335 RETCODE := MSC_UTIL.G_ERROR;
4336
4337 RETURN;
4338
4339 END IF;
4340
4341 ELSIF MSC_UTIL.G_MSC_CONFIGURATION = MSC_UTIL.G_CONF_APS THEN
4342 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, 'before MSC_CL_SETUP_ODS_LOAD.CLEANSE_DATA and MSC_CL_SETUP_ODS_LOAD.TRANSFORM_KEYS ');
4343 IF MSC_CL_SETUP_ODS_LOAD.CLEANSE_DATA AND MSC_CL_SETUP_ODS_LOAD.TRANSFORM_KEYS THEN
4344 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 ');
4345 COMMIT;
4346 ELSE
4347 FND_MESSAGE.SET_NAME('MSC','MSC_CL_TRANSFORM_KEY_ERR');
4348 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
4349
4350 ROLLBACK;
4351
4352 FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_DC_FAIL');
4353 ERRBUF:= FND_MESSAGE.GET;
4354 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, ERRBUF);
4355 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, SQLERRM);
4356
4357 IF SET_ST_STATUS( ERRBUF, RETCODE, pINSTANCE_ID, MSC_UTIL.G_ST_READY) THEN
4358 COMMIT;
4359 END IF;
4360 RETCODE := MSC_UTIL.G_ERROR;
4361
4362 RETURN;
4363
4364 END IF;
4365 END IF; -- G_MSC_CONFIGURATION
4366
4367 --bug3954345. Setting so_tbl_status to 2 so that ATP inquiry doesn't go through
4368 --unless all the related ATP tables are populated
4369
4370 MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'update so_tbl status to no');
4371 IF (v_coll_prec.tp_vendor_flag = MSC_UTIL.SYS_YES OR v_coll_prec.tp_customer_flag = MSC_UTIL.SYS_YES OR v_coll_prec.sourcing_rule_flag=MSC_UTIL.SYS_YES OR v_coll_prec.atp_rules_flag=MSC_UTIL.SYS_YES) THEN
4372 UPDATE MSC_APPS_INSTANCES mai
4373 SET
4374 so_tbl_status= MSC_UTIL.SYS_NO,
4375 LAST_UPDATE_DATE= v_current_date,
4376 LAST_UPDATED_BY= v_current_user,
4377 REQUEST_ID= FND_GLOBAL.CONC_REQUEST_ID
4378 WHERE mai.INSTANCE_ID= v_instance_id;
4379 commit;
4380 END IF;
4381
4382 -- ============ Load Orgnization, Designator, UOM ==============
4383 /* load trading_partner first to provide organization_code information */
4384
4385 FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
4386 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SETUP_ODS_LOAD.LOAD_TRADING_PARTNER');
4387 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
4388 MSC_CL_SETUP_ODS_LOAD.LOAD_TRADING_PARTNER;
4389
4390 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, 'after MSC_CL_SETUP_ODS_LOAD.LOAD_TRADING_PARTNER');
4391
4392 /* SCE Change starts */
4393 /* By this time Trading Partners , Organizations are loaded into planning area
4394 as well as collaboration area.
4395 Now we can populate the msc_trading_partner_maps table.
4396
4397 Perform this step if the profile option is 'APS + SCE' OR 'SCE'.
4398 */
4399 IF MSC_UTIL.G_MSC_CONFIGURATION = MSC_UTIL.G_CONF_APS_SCE OR
4400 MSC_UTIL.G_MSC_CONFIGURATION = MSC_UTIL.G_CONF_SCE THEN
4401
4402 FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
4403 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SCE_COLLECTION.POPULATE_TP_MAP_TABLE');
4404 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
4405
4406 MSC_CL_SCE_COLLECTION.POPULATE_TP_MAP_TABLE(v_instance_id);
4407
4408 END IF;
4409 /* SCE Change ends */
4410
4411 COMMIT;
4412
4413 /* Load parameters in the Main ODS Load so that this information is available to the function
4414 CALC_RESOURCE_AVAILABILITY called within LOAD_CALENDAR_DATE */
4415
4416 FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
4417 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SETUP_ODS_LOAD.LOAD_PARAMETER');
4418 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
4419 MSC_CL_SETUP_ODS_LOAD.LOAD_PARAMETER;
4420
4421 COMMIT;
4422
4423 MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'after MSC_CL_SETUP_ODS_LOAD.LOAD_PARAMETER');
4424 /* SCE Change starts */
4425
4426 /* Populate msc_st_item_suppliers with company_id and company_site_id
4427 This step is required only if MSC:Configuration = 'SCE' or 'APS + SCE'
4428 */
4429
4430 /* This is post transform keys process. */
4431
4432 IF MSC_UTIL.G_MSC_CONFIGURATION = MSC_UTIL.G_CONF_APS_SCE OR
4433 MSC_UTIL.G_MSC_CONFIGURATION = MSC_UTIL.G_CONF_SCE THEN
4434
4435 FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
4436 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SCE_COLLECTION.CLEANSE_TP_ITEMS');
4437 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
4438 MSC_CL_SCE_COLLECTION.CLEANSE_TP_ITEMS(v_instance_id);
4439
4440 END IF;
4441
4442 /* SCE Change ends */
4443
4444 /* load schedule to provide schedule designator information */
4445
4446 FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
4447 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LOAD_DESIGNATOR');
4448 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
4449 MSC_CL_DEMAND_ODS_LOAD.LOAD_DESIGNATOR;
4450
4451 COMMIT;
4452
4453 MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'after MSC_CL_DEMAND_ODS_LOAD.LOAD_DESIGNATOR');
4454 /* load forecast designators */
4455
4456 FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
4457 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LOAD_FORECASTS');
4458 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
4459 MSC_CL_DEMAND_ODS_LOAD.LOAD_FORECASTS;
4460
4461 COMMIT;
4462
4463 /* USAF load eam-CMRO designators */
4464
4465 IF (v_apps_ver >= MSC_UTIL.G_EAM_CMRO_SUP_VER
4466 AND MSC_UTIL.G_CMRO_EAM_INT_ENABLED = 'Y' ) THEN
4467
4468 FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
4469 FND_MESSAGE.SET_TOKEN('PROCEDURE',
4470 'MSC_CL_DEMAND_ODS_LOAD.LOAD_CMRO_EAM_FORECASTS');
4471 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
4472 MSC_CL_DEMAND_ODS_LOAD.LOAD_CMRO_EAM_FORECASTS ;
4473 COMMIT;
4474
4475 END IF;
4476
4477 /* load unit of measure */
4478
4479 FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
4480 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SETUP_ODS_LOAD.LOAD_UOM');
4481 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
4482 MSC_CL_SETUP_ODS_LOAD.LOAD_UOM;
4483
4484 COMMIT;
4485
4486 /* CP-ACK starts */
4487 -- ============================================================
4488 -- We will also load Calendar Dates as Set up entity.
4489 -- We need to do these changes since CP code refers to Calendar
4490 -- ============================================================
4491 FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
4492 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SETUP_ODS_LOAD.LOAD_CALENDAR_SET_UP');
4493 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
4494 MSC_CL_SETUP_ODS_LOAD.LOAD_CALENDAR_SET_UP;
4495
4496 /* CP-ACK ends */
4497
4498 IF v_is_complete_refresh THEN
4499 msc_analyse_tables_pk.analyse_table( 'MSC_TRADING_PARTNERS');
4500 msc_analyse_tables_pk.analyse_table( 'MSC_DESIGNATORS');
4501 END IF;
4502
4503
4504 IF (v_instance_type <> MSC_UTIL.G_INS_OTHER) AND (v_is_complete_refresh OR
4505 (v_is_partial_refresh AND -- BUG 13724715 (FP of bug 13907513)
4506 (v_coll_prec.resource_nra_flag = MSC_UTIL.SYS_YES OR
4507 v_coll_prec.resource_nra_flag = REGEN_AND_COLLECT))) THEN
4508 -- DELETE_MSC_TABLE( 'MSC_NET_RESOURCE_AVAIL', v_instance_id, -1);
4509 -- DELETE_MSC_TABLE( 'MSC_NET_RES_INST_AVAIL', v_instance_id, -1);
4510 IF v_coll_prec.org_group_flag = MSC_UTIL.G_ALL_ORGANIZATIONS THEN
4511 DELETE_MSC_TABLE( 'MSC_NET_RESOURCE_AVAIL', v_instance_id, -1);
4512 DELETE_MSC_TABLE( 'MSC_NET_RES_INST_AVAIL', v_instance_id, -1);
4513 ELSE
4514 v_sub_str :=' AND ORGANIZATION_ID '||MSC_UTIL.v_in_org_str;
4515 DELETE_MSC_TABLE( 'MSC_NET_RESOURCE_AVAIL', v_instance_id, -1,v_sub_str);
4516 DELETE_MSC_TABLE( 'MSC_NET_RES_INST_AVAIL', v_instance_id, -1,v_sub_str);
4517 END IF;
4518 END IF;
4519 MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'before launching workers');
4520 -- ============ Lauch the Workers here ===============
4521
4522 lvs_request_id.EXTEND( pTotalWorkerNum);
4523
4524 IF v_cp_enabled= MSC_UTIL.SYS_YES THEN
4525
4526 FOR lc_i IN 1..pTotalWorkerNum LOOP
4527 MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'before launching worker:' || to_char(lc_i));
4528 lvs_request_id(lc_i) := FND_REQUEST.SUBMIT_REQUEST(
4529 'MSC',
4530 'MSCPDCW',
4531 NULL, -- description
4532 NULL, -- start date
4533 FALSE, -- TRUE,
4534 FND_GLOBAL.CONC_REQUEST_ID,
4535 pINSTANCE_ID,
4536 v_last_collection_id,
4537 pTIMEOUT,
4538 lv_pRECALC_NRA_NEW,
4539 pRECALC_SH,
4540 v_exchange_mode,
4541 v_so_exchange_mode);
4542
4543 COMMIT;
4544
4545 IF lvs_request_id(lc_i)= 0 THEN
4546
4547 ROLLBACK;
4548
4549 IF SET_ST_STATUS( ERRBUF, RETCODE, pINSTANCE_ID, MSC_UTIL.G_ST_READY) THEN
4550 COMMIT;
4551 END IF;
4552
4553 FOR lc_i IN 1..pTotalWorkerNum LOOP
4554
4555 DBMS_PIPE.PACK_MESSAGE( -1);
4556
4557 IF DBMS_PIPE.SEND_MESSAGE( v_pipe_task_que)<>0 THEN
4558 RAISE EX_PIPE_SND;
4559 END IF;
4560
4561 FND_MESSAGE.SET_NAME('MSC','MSC_CL_SEND_WOR_END');
4562 FND_MESSAGE.SET_TOKEN('LCI',lc_i);
4563 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
4564 END LOOP;
4565
4566 FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_LAUNCH_WORKER_FAIL');
4567 ERRBUF:= FND_MESSAGE.GET;
4568 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, ERRBUF);
4569 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, SQLERRM);
4570
4571 RETCODE := MSC_UTIL.G_ERROR;
4572
4573 COMMIT;
4574
4575 RETURN;
4576 ELSE
4577 FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_WORKER_REQUEST_ID');
4578 FND_MESSAGE.SET_TOKEN('REQUEST_ID', lvs_request_id(lc_i));
4579 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
4580 END IF;
4581
4582 END LOOP;
4583
4584 ELSE
4585
4586 COMMIT;
4587
4588 END IF; -- DEVELOPING
4589
4590 msc_util.print_trace_file_name(FND_GLOBAL.CONC_REQUEST_ID);
4591
4592 -- ============ Send Tasks to Task Que 'v_pipe_task_que' =============
4593 -- load sales orders will be called from load_supply - link demand-supply
4594 /* ds change */
4595 if v_coll_prec.ds_mode = MSC_UTIL.SYS_YES THEN
4596 total_task := TOTAL_PARTIAL_TASKS;
4597 else
4598 total_task := TOTAL_TASK_NUMBER;
4599 end if;
4600
4601 FOR lc_i IN 1..total_task LOOP
4602 -- IF v_is_so_incremental_refresh AND
4603 -- IF lc_i = TASK_SALES_ORDER THEN
4604 -- lv_total_task_number:= TOTAL_TASK_NUMBER-1;
4605 -- MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'Removed the task for Sales orders');
4606 -- ELSE
4607 /* ds_change start*/
4608 MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'ds mode= '||to_char(v_coll_prec.ds_mode));
4609
4610 IF v_coll_prec.ds_mode = MSC_UTIL.SYS_YES THEN
4611 IF Q_PARTIAL_TASK (pINSTANCE_ID, lc_i) THEN
4612 DBMS_PIPE.PACK_MESSAGE( lc_i);
4613 lv_task_not_completed := lv_task_not_completed + 1;
4614
4615 MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'Sending DS task number: '||lc_i||' to the queue');
4616
4617 IF DBMS_PIPE.SEND_MESSAGE( v_pipe_task_que) <> 0 THEN
4618
4619 FND_MESSAGE.SET_NAME('MSC','MSC_CL_ERROR_SEND_TSK');
4620 FND_MESSAGE.SET_TOKEN('LCI',lc_i);
4621 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
4622
4623 RAISE EX_PIPE_SND;
4624 END IF;
4625 ELSE
4626
4627 MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'task: '||lc_i|| ' not loaded for worker ');
4628 END IF; /* Q_PARTIAL_TASK */
4629
4630 /* ds_change end*/
4631 ELSE
4632
4633 MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'Sending task number: '||lc_i||' to the queue');
4634 DBMS_PIPE.PACK_MESSAGE( lc_i);
4635 lv_task_not_completed := lv_task_not_completed + 1;
4636
4637
4638 IF DBMS_PIPE.SEND_MESSAGE( v_pipe_task_que)<>0 THEN
4639
4640 FND_MESSAGE.SET_NAME('MSC','MSC_CL_ERROR_SEND_TSK');
4641 FND_MESSAGE.SET_TOKEN('LCI',lc_i);
4642 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
4643
4644 RAISE EX_PIPE_SND;
4645 END IF;
4646 END IF; /* v_DSMode */
4647 END LOOP;
4648
4649 DBMS_LOCK.SLEEP( 5); -- initial estimated sleep time
4650
4651 --lv_task_not_completed := lv_total_task_number;
4652
4653 lv_bon_start_end :=0; -- bug9194726
4654 FND_MESSAGE.SET_NAME('MSC','MSC_CL_TOTAL_TSK_ADDED');
4655 FND_MESSAGE.SET_TOKEN('LV_TASK_NOT_COMPLETED',lv_task_not_completed);
4656 MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, FND_MESSAGE.GET);
4657
4658 LOOP
4659
4660 var_debug := 1;
4661 EXIT WHEN is_request_status_running <> MSC_UTIL.SYS_YES;
4662
4663 var_debug := 2;
4664 EXIT WHEN is_worker_status_valid(lvs_request_id) <> MSC_UTIL.SYS_YES;
4665
4666 lv_pipe_ret_code:= DBMS_PIPE.RECEIVE_MESSAGE( v_pipe_wm, PIPE_TIME_OUT);
4667 MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'Pipe Return code: '||lv_pipe_ret_code);
4668
4669 IF lv_pipe_ret_code=0 THEN
4670
4671 DBMS_PIPE.UNPACK_MESSAGE( lv_task_number);
4672 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, 'Unpacked Task Number : '||lv_task_number);
4673
4674 if lv_task_number = TASK_ATP_RULES THEN
4675 G_TASK_ATP_RULES :=1;
4676 elsif lv_task_number = TASK_SOURCING THEN
4677 G_TASK_SOURCING :=1;
4678 elsif lv_task_number = TASK_ROUTING THEN
4679 lv_bon_start_end := lv_bon_start_end + 1;
4680 elsif lv_task_number = TASK_OPERATION_NETWORKS THEN
4681 lv_bon_start_end := lv_bon_start_end + 1;
4682 elsif lv_task_number = TASK_ROUTING_OPERATIONS THEN
4683 lv_bon_start_end := lv_bon_start_end + 1;
4684 END if;
4685
4686
4687 if G_TASK_ATP_RULES =1 and G_TASK_SOURCING =1 then
4688 UPDATE MSC_APPS_INSTANCES mai
4689 SET
4690 so_tbl_status= MSC_UTIL.SYS_YES,
4691 LAST_UPDATE_DATE= v_current_date,
4692 LAST_UPDATED_BY= v_current_user,
4693 REQUEST_ID= FND_GLOBAL.CONC_REQUEST_ID
4694 WHERE mai.INSTANCE_ID= v_instance_id;
4695 MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'update so tbl status');
4696 commit;
4697 G_TASK_ATP_RULES :=0;
4698 G_TASK_SOURCING :=0;
4699 end if;
4700
4701 IF lv_task_number>0 THEN -- If it's ok, the vlaue is the task number
4702
4703 lv_task_not_completed := lv_task_not_completed -1;
4704 MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'Tasks remaining :'||lv_task_not_completed);
4705
4706 IF lv_task_not_completed= 0 THEN
4707 var_debug := 3;
4708 EXIT;
4709 END IF;
4710
4711 ELSE
4712
4713 var_debug := 4;
4714 EXIT WHEN lv_task_number= UNRESOVLABLE_ERROR;
4715
4716 DBMS_PIPE.PACK_MESSAGE( -lv_task_number); -- resend the task to the task que
4717
4718 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, 'Re-sending the task number: '||lv_task_number||' to the queue');
4719
4720 IF DBMS_PIPE.SEND_MESSAGE( v_pipe_task_que)<>0 THEN
4721 RAISE EX_PIPE_SND;
4722 END IF;
4723
4724 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, 'Task number: '||lv_task_number||' re-sent to the pipe queue');
4725 END IF;
4726
4727 ELSIF lv_pipe_ret_code<> 1 THEN
4728 FND_MESSAGE.SET_NAME('MSC','MSC_CL_RCV_PIPE_ERR');
4729 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
4730
4731 RAISE EX_PIPE_RCV; -- If the error is not time-out error
4732 END IF;
4733
4734 -- ============= Check the execution time ==============
4735
4736 select (SYSDATE- START_TIME) into lv_process_time from dual;
4737
4738 IF lv_process_time > pTIMEOUT/1440.0 THEN Raise EX_PROCESS_TIME_OUT;
4739 END IF;
4740
4741 END LOOP;
4742
4743 MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, '----------------------------------------------------');
4744 FND_MESSAGE.SET_NAME('MSC','MSC_CL_TSK_NOT_COMP');
4745 FND_MESSAGE.SET_TOKEN('LV_TASK_NOT_COMPLETED',lv_task_not_completed);
4746 MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, FND_MESSAGE.GET);
4747
4748 IF (var_debug = 1) THEN
4749 FND_MESSAGE.SET_NAME('MSC','MSC_CL_ERR_PDC_1');
4750 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
4751 ELSIF (var_debug = 2) THEN
4752 FND_MESSAGE.SET_NAME('MSC','MSC_CL_ERR_PDC_2');
4753 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
4754 ELSIF (var_debug = 3) THEN
4755 FND_MESSAGE.SET_NAME('MSC','MSC_CL_ERR_PDC_3');
4756 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
4757 ELSIF (var_debug = 4) THEN
4758 FND_MESSAGE.SET_NAME('MSC','MSC_CL_ERR_PDC_4');
4759 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
4760 END IF;
4761
4762 MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, '----------------------------------------------------');
4763
4764 IF lv_task_not_completed > 0 THEN
4765
4766 DBMS_PIPE.PURGE( v_pipe_task_que);
4767
4768 lv_task_number:= -1;
4769
4770 ROLLBACK;
4771
4772 FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_FAIL');
4773 ERRBUF:= FND_MESSAGE.GET;
4774 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, ERRBUF);
4775 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, SQLERRM);
4776
4777 RETCODE := MSC_UTIL.G_ERROR;
4778
4779 ELSE
4780
4781 lv_task_number:= 0;
4782
4783 UPDATE MSC_APPS_INSTANCES mai
4784 SET LAST_UPDATE_DATE= v_current_date,
4785 LAST_UPDATED_BY= v_current_user,
4786 REQUEST_ID= FND_GLOBAL.CONC_REQUEST_ID
4787 WHERE mai.INSTANCE_ID= v_instance_id;
4788 commit;
4789
4790 IF (v_is_complete_refresh) THEN
4791 IF MSC_CL_SUPPLY_ODS_LOAD.drop_supplies_tmp_ind THEN
4792 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, 'Index Dropping on Temp Supplies table successful.');
4793 ELSE
4794 ROLLBACK;
4795 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, 'Failed in Dropping the temp Index on Supplies table.' );
4796 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, SQLERRM);
4797
4798 RETCODE := MSC_UTIL.G_ERROR;
4799 RAISE SUPPLIES_INDEX_FAIL;
4800 END IF;
4801 END IF;
4802
4803 FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_SUCCEED');
4804 ERRBUF:= FND_MESSAGE.GET;
4805 RETCODE := MSC_UTIL.G_SUCCESS ;
4806
4807 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, ERRBUF);
4808
4809 END IF;
4810
4811 lv_debug_ret := RETCODE;
4812
4813 IF SET_ST_STATUS( ERRBUF, RETCODE, pINSTANCE_ID, MSC_UTIL.G_ST_READY) THEN
4814 COMMIT;
4815 END IF;
4816
4817 IF (lv_debug_ret = MSC_UTIL.G_ERROR) OR (RETCODE = MSC_UTIL.G_ERROR) THEN
4818 RETCODE := MSC_UTIL.G_ERROR;
4819 END IF;
4820
4821 FOR lc_i IN 1..pTotalWorkerNum LOOP
4822
4823 FND_MESSAGE.SET_NAME('MSC','MSC_CL_SEND_WOR_END');
4824 FND_MESSAGE.SET_TOKEN('LCI',lc_i);
4825 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
4826
4827 DBMS_PIPE.PACK_MESSAGE( lv_task_number);
4828
4829 MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'Sending task number: '||lv_task_number||' to the worker '||lc_i);
4830 IF DBMS_PIPE.SEND_MESSAGE( v_pipe_task_que)<>0 THEN
4831 RAISE EX_PIPE_SND;
4832 END IF;
4833
4834 END LOOP;
4835
4836 lv_worker_committed:= 0;
4837
4838 lv_start_time:= SYSDATE;
4839
4840 LOOP
4841
4842 lv_pipe_ret_code:= DBMS_PIPE.RECEIVE_MESSAGE( v_pipe_status, PIPE_TIME_OUT);
4843
4844 IF lv_pipe_ret_code=0 THEN
4845
4846 lv_worker_committed:= lv_worker_committed+1;
4847
4848 FND_MESSAGE.SET_NAME('MSC','MSC_CL_WORKER_COMMIT');
4849 FND_MESSAGE.SET_TOKEN('LV_WORKER_COMMITTED',lv_worker_committed);
4850 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
4851
4852 EXIT WHEN lv_worker_committed= pTotalWorkerNum;
4853
4854 ELSIF lv_pipe_ret_code<> 1 THEN
4855 RAISE EX_PIPE_RCV; -- If the error is not time-out error
4856 END IF;
4857
4858 SELECT (SYSDATE- lv_start_time) INTO lv_process_time FROM dual;
4859 --EXIT WHEN lv_process_time > 10.0/1440.0; -- wait for 10 minutes
4860 IF ( lv_process_time > 3.0/1440.0) AND (lv_worker_committed <> pTotalWorkerNum) THEN
4861 EXIT WHEN all_workers_completed(lvs_request_id) = MSC_UTIL.SYS_YES;
4862 END IF;
4863
4864 END LOOP;
4865
4866 IF lv_worker_committed<> pTotalWorkerNum THEN
4867
4868 FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_FAIL_TO_COMMIT');
4869 ERRBUF:= FND_MESSAGE.GET;
4870 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, ERRBUF);
4871 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, SQLERRM);
4872
4873 FND_MESSAGE.SET_NAME('MSC','MSC_CL_CHECK_PDC_LOG');
4874 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
4875
4876 RETCODE := MSC_UTIL.G_ERROR;
4877
4878 ELSE
4879
4880 IF lv_task_number= 0 THEN
4881
4882 IF v_apps_ver >= MSC_UTIL.G_APPS115 THEN --Version
4883 /* call the function to link the Demand_id and Parent_id in MSC_DEMANDS for 11i Source instance */
4884
4885 IF MSC_CL_DEMAND_ODS_LOAD.LINK_PARENT_SALES_ORDERS_MDS THEN
4886 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, 'Linking of Sales Order line in MDS to its Parent Sales orders is successful.....');
4887 ELSE
4888 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, 'Error in Linking Sales order line in MDS to its parent Sales order......');
4889 RETCODE := MSC_UTIL.G_WARNING;
4890 END IF;
4891 END IF;
4892
4893 /* ds change start */
4894 IF v_apps_ver >= MSC_UTIL.G_APPS115 THEN
4895 IF MSC_CL_SETUP_ODS_LOAD.LINK_SUPPLY_TOP_LINK_ID THEN
4896 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, 'update of msc_supplies top_transaction_id for eam is successful.....');
4897 ELSE
4898 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, 'Error in update of msc_supplies top_transaction_id......');
4899 RETCODE := MSC_UTIL.G_WARNING;
4900 END IF;
4901 END IF;
4902 /* ds change end */
4903 IF (v_is_complete_refresh) THEN
4904 IF (MSC_CL_SUPPLY_ODS_LOAD.drop_supplies_tmp_ind and MSC_CL_DEMAND_ODS_LOAD.drop_demands_tmp_ind and MSC_CL_DEMAND_ODS_LOAD.drop_sales_orders_tmp_ind) THEN
4905 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, 'Index Dropping on Temp Tables successful.');
4906 ELSE
4907 ROLLBACK;
4908 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, 'Failed in Dropping the Indexes on Temp Tables.' );
4909 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, SQLERRM);
4910
4911 RETCODE := MSC_UTIL.G_ERROR;
4912 RAISE SUPPLIES_INDEX_FAIL;
4913 END IF;
4914 END IF;
4915
4916 IF v_exchange_mode= MSC_UTIL.SYS_YES THEN
4917
4918 IF alter_temp_table_by_monitor = FALSE THEN
4919 RETCODE:= MSC_UTIL.G_ERROR;
4920 ELSE
4921 --log_message ('successfully altered phase 2 tables');
4922 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, 'successfully altered phase 2 tables.' );
4923 NULL;
4924 END IF;
4925
4926 IF NOT MSC_CL_EXCHANGE_PARTTBL.Exchange_Partition THEN
4927 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS,
4928 'Fatal Error in Exchange Partition.' );
4929 RETCODE:= MSC_UTIL.G_ERROR;
4930 END IF;
4931 IF NOT MSC_CL_EXCHANGE_PARTTBL.Drop_Temp_Tbl THEN
4932 v_warning_flag:=MSC_UTIL.SYS_YES;
4933 END IF;
4934
4935 END IF;
4936
4937 IF (v_req_ext_po_so_linking) Then
4938 IF ( v_apps_ver >= MSC_UTIL.G_APPS115 ) THEN
4939 BEGIN
4940 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, ' Calling Linking of Sales Order for 11i source ...');
4941 FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
4942 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LINK_SUPP_SO_DEMAND_EXT');
4943 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
4944 -- Calling the Linking of external Sales orders for the fix 2353397 --
4945 MSC_CL_DEMAND_ODS_LOAD.LINK_SUPP_SO_DEMAND_EXT;
4946 END;
4947
4948 END IF;
4949 END IF;
4950
4951 IF ( v_coll_prec.item_flag = MSC_UTIL.SYS_YES or v_coll_prec.bom_flag = MSC_UTIL.SYS_YES ) THEN
4952 MSC_CL_ITEM_ODS_LOAD.UPDATE_LEADTIME;
4953 END IF;
4954
4955 IF (v_apps_ver >= MSC_UTIL.G_EAM_CMRO_SUP_VER AND MSC_UTIL.G_CMRO_EAM_INT_ENABLED = 'Y' ) THEN
4956 IF ( v_coll_prec.eam_info_flag = MSC_UTIL.SYS_YES OR v_coll_prec.bom_flag = MSC_UTIL.SYS_YES ) THEN
4957 MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'Calling LINK_REBUILD_BOM_ACTIVITY');
4958 MSC_CL_EAM_ODS_LOAD.LINK_REBUILD_BOM_ACTIVITY;
4959 END IF;
4960 END IF;
4961
4962 IF (v_apps_ver >= MSC_UTIL.G_EAM_CMRO_SUP_VER AND MSC_UTIL.G_CMRO_EAM_INT_ENABLED = 'Y' ) THEN
4963 IF ( v_coll_prec.eam_info_flag = MSC_UTIL.SYS_YES OR v_coll_prec.wip_flag = MSC_UTIL.SYS_YES ) THEN
4964 MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'Calling UPD_PROD_STOCK ');
4965 MSC_CL_EAM_ODS_LOAD.UPD_PROD_STOCK;
4966 END IF;
4967 END IF;
4968
4969 IF lv_bon_start_end = 3 THEN
4970 MSC_CL_ROUTING_ODS_LOAD.GET_START_END_OP ;
4971 END IF;
4972 UPDATE MSC_APPS_INSTANCES
4973 SET so_tbl_status= MSC_UTIL.SYS_YES
4974 WHERE instance_id= v_instance_id;
4975 /*Resource Start Time*/
4976 -- Set The collections Start Time . Get the start time in the out variable
4977 SET_COLLECTIONS_START_TIME(v_instance_id, v_resource_start_time);
4978
4979 IF RETCODE <> MSC_UTIL.G_ERROR THEN
4980 IF v_coll_prec.ibuc_history_flag = MSC_UTIL.SYS_YES THEN
4981 UPDATE MSC_APPS_INSTANCES
4982 SET LAST_IBUC_COLL_DATE = lv_ibuc_coll_start_time
4983 WHERE INSTANCE_ID= pINSTANCE_ID;
4984 END IF;
4985 END IF;
4986
4987 COMMIT;
4988
4989 IF(v_coll_prec.po_receipts_flag = MSC_UTIL.SYS_YES) THEN
4990 v_sub_str := 'AND ORGANIZATION_ID' || MSC_UTIL.v_in_org_str;
4991 DELETE_MSC_TABLE('MSC_PO_RECEIPTS', v_instance_id,NULL,v_sub_str);
4992 --DELETE MSC_PO_RECEIPTS
4993 --WHERE SR_INSTANCE
4994 COMMIT;
4995
4996 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, 'Table MSC_PO_RECEIPTS Deleted');
4997
4998 MSC_CL_MISCELLANEOUS.load_po_receipts
4999 ( v_instance_id,
5000 MSC_UTIL.v_in_org_str,
5001 v_last_collection_id,
5002 v_current_date,
5003 v_current_user,
5004 NULL);
5005 COMMIT;
5006 END IF;
5007
5008 IF (pPURGE_SH = MSC_UTIL.SYS_YES) THEN
5009
5010 SELECT DECODE(nvl(FND_PROFILE.VALUE('MSC_PURGE_ST_CONTROL'),'N'),'Y',1,2)
5011 INTO lv_delete_flag
5012 FROM DUAL;
5013 -- If the above profile option is set then we are assuming that there is only one source
5014 -- So we can safely truncate the msc_sourcing_history table to improve performance
5015 IF (lv_delete_flag = 2) THEN
5016 DELETE MSC_SOURCING_HISTORY
5017 WHERE SR_INSTANCE_ID = v_instance_id;
5018 ELSE
5019 TRUNCATE_MSC_TABLE('MSC_SOURCING_HISTORY');
5020 END IF;
5021
5022 COMMIT;
5023
5024 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, 'Table MSC_SOURCING_HISTORY Deleted');
5025
5026 END IF;
5027
5028 IF pRECALC_SH= MSC_UTIL.SYS_YES THEN
5029
5030 MSC_CL_MISCELLANEOUS.load_sourcing_history
5031 ( v_instance_id,
5032 v_last_collection_id,
5033 v_current_date,
5034 v_current_user,
5035 NULL);
5036 END IF;
5037
5038 -- SAVEPOINT WORKERS_COMMITTED;
5039
5040 -- BUG # 3020614
5041 -- For Partial refresh, if Both the bom_flag and calendar_flag are
5042 -- not set then call the procedure calc_resource_availability in
5043 -- serial mode if lv_pRECALC_NRA_NEW is set.
5044 -- Otherwise, the procedure load_calendar_date makes a call to
5045 -- this procedure.
5046
5047
5048 IF (v_is_partial_refresh AND
5049 (v_coll_prec.bom_flag = MSC_UTIL.SYS_NO) AND
5050 (v_coll_prec.calendar_flag = MSC_UTIL.SYS_NO)) THEN
5051
5052
5053 IF v_discrete_flag= MSC_UTIL.SYS_YES AND lv_pRECALC_NRA_NEW= MSC_UTIL.SYS_YES THEN
5054 IF v_instance_type = MSC_UTIL.G_INS_OTHER THEN
5055 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, 'MSC_UTIL.G_INS_OTHER: Deleting MSC_NET_RESOURCE_AVAIL...');
5056 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, 'debug-03');
5057 DELETE_MSC_TABLE( 'MSC_NET_RESOURCE_AVAIL', v_instance_id, -1,MSC_UTIL.v_in_org_str);
5058 DELETE_MSC_TABLE( 'MSC_NET_RES_INST_AVAIL', v_instance_id, -1,MSC_UTIL.v_in_org_str);
5059 END IF;
5060 /* Resource Start TIme Changes */
5061
5062 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS,'before CALC_RESOURCE_AVAILABILITY ');
5063 lv_ret_res_ava:=MSC_RESOURCE_AVAILABILITY.CALC_RESOURCE_AVAILABILITY(v_resource_start_time,v_coll_prec.org_group_flag,FALSE);
5064
5065
5066 IF lv_ret_res_ava = 2 THEN
5067 FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_CALC_RES_AVAIL_FAIL');
5068 ERRBUF:= FND_MESSAGE.GET;
5069 v_warning_flag:=MSC_UTIL.SYS_YES;
5070 ELSIF lv_ret_res_ava <> 0 THEN
5071 FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_CALC_RES_AVAIL_FAIL');
5072 ERRBUF:= FND_MESSAGE.GET;
5073 RETCODE:= MSC_UTIL.G_ERROR;
5074
5075
5076 -- ROLLBACK WORK TO SAVEPOINT WORKERS_COMMITTED;
5077
5078 END IF;
5079
5080 END IF;
5081 END IF;
5082
5083 END IF; -- lv_task_number= 0
5084
5085 END IF; -- commit fail?
5086
5087 COMMIT;
5088
5089 /* LAUNCH DATA PURGING PROCESS */
5090
5091 IF (v_cp_enabled= MSC_UTIL.SYS_YES AND RETCODE<>MSC_UTIL.G_ERROR) THEN
5092
5093 /* added the code so that the request - Purge Staging tables will be called via function
5094 purge_staging for bug: 2452183 , Planning ODS Load was always completing with warnings
5095 because when the sub-req MSCPDCP completes , it restarts the launch_monitor */
5096
5097 IF PURGE_STAGING(pINSTANCE_ID) THEN
5098 COMMIT;
5099 ELSE
5100 IF RETCODE <> MSC_UTIL.G_ERROR THEN RETCODE := MSC_UTIL.G_WARNING; END IF;
5101 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, SQLERRM);
5102 END IF;
5103
5104 END IF;
5105
5106 COMMIT;
5107
5108 IF ( v_is_complete_refresh ) AND ( v_coll_prec.org_group_flag=MSC_UTIL.G_ALL_ORGANIZATIONS ) THEN
5109
5110 BEGIN
5111 SELECT DECODE(M2A_DBLINK,
5112 NULL,'',
5113 '@'||M2A_DBLINK)
5114 INTO lv_dblink
5115 FROM MSC_APPS_INSTANCES
5116 WHERE INSTANCE_ID=v_instance_id;
5117 lv_sql_stmt:=
5118 'BEGIN MRP_CL_REFRESH_SNAPSHOT.PURGE_OBSOLETE_DATA'||lv_dblink||';END;';
5119
5120 EXECUTE IMMEDIATE lv_sql_stmt;
5121
5122 COMMIT;
5123
5124 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, 'Truncated Source AD Tables Successfully');
5125
5126 EXCEPTION
5127 WHEN OTHERS THEN
5128 ERRBUF:=SQLERRM||' Error in Call to Purge Obsolete Data ';
5129 v_warning_flag := MSC_UTIL.SYS_YES;
5130 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, ERRBUF);
5131
5132 END;
5133
5134 END IF; -- complete refresh is yes
5135
5136 /* ATP SUMMARY CHANGES - LAUNCH CONCURENT PROGRAMS FOR ATP */
5137 /* CHECK TO SEE IF THE PACKAGE EXISTS */
5138 BEGIN
5139 OPEN c_query_package;
5140 FETCH c_query_package INTO lv_atp_package_exists;
5141 CLOSE c_query_package;
5142 /* CHECK TO SEE IF THE ATP PROFILE INV_CTP is set to 5 */
5143 SELECT nvl(fnd_profile.value('INV_CTP'),-10)
5144 INTO lv_inv_ctp
5145 FROM dual;
5146
5147 /* CHECK TO SEE IF THE ATP PROFILE INV_CTP is set to 5 */
5148 SELECT decode(nvl(fnd_profile.value('MSC_ENABLE_ATP_SUMMARY'),'N'),'Y',1,2)
5149 INTO lv_MSC_ENABLE_ATP_SUMMARY
5150 FROM dual;
5151
5152 EXCEPTION
5153 WHEN OTHERS THEN
5154 IF c_query_package%ISOPEN THEN CLOSE c_query_package; END IF;
5155 lv_atp_package_exists := 2;
5156 END;
5157
5158 IF (lv_atp_package_exists = 1 AND lv_inv_ctp = 5 and lv_MSC_ENABLE_ATP_SUMMARY = 1 ) THEN
5159 IF v_is_complete_refresh THEN
5160
5161 BEGIN
5162 IF (v_cp_enabled= MSC_UTIL.SYS_YES AND v_is_so_complete_refresh ) THEN
5163 lv_atp_request_id := FND_REQUEST.SUBMIT_REQUEST(
5164 'MSC',
5165 'MSCCLCNC',
5166 NULL, -- description
5167 NULL, -- start date
5168 FALSE, -- sub request,
5169 pINSTANCE_ID, -- Instance Id
5170 MSC_UTIL.SYS_YES, -- Refresh type complete
5171 MSC_UTIL.SYS_YES, -- Refresh SO Complete
5172 MSC_UTIL.SYS_YES); -- Refresh Supply/Demand
5173 END IF;
5174 IF (v_cp_enabled= MSC_UTIL.SYS_YES AND v_is_so_incremental_refresh ) THEN
5175 lv_atp_request_id := FND_REQUEST.SUBMIT_REQUEST(
5176 'MSC',
5177 'MSCCLCNC',
5178 NULL, -- description
5179 NULL, -- start date
5180 FALSE, -- sub request,
5181 pINSTANCE_ID, -- Instance Id
5182 MSC_UTIL.SYS_YES, -- Refresh type complete
5183 MSC_UTIL.SYS_NO, -- Refresh SO Incremental
5184 MSC_UTIL.SYS_YES); -- Refresh Supply/Demand
5185
5186 END IF;
5187 COMMIT;
5188 EXCEPTION
5189 WHEN OTHERS THEN
5190 ERRBUF:=SQLERRM||' Request: '||lv_atp_request_id||' Error in Call To program MSCCLCNC ';
5191 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, ERRBUF);
5192 END;
5193
5194 END IF; -- Complete refresh Condition
5195 END IF; -- ATP Package exists or not and the profile options are set or not
5196 /* ATP SUMMARY CHANGES - END - LAUNCH CONCURENT PROGRAMS FOR ATP */
5197
5198 /* SCE Change Starts */
5199 /* If MSC:Configuration profile is set to SCE or APS+SCE then we need to publish
5200 ODS data to collaboration area i.e. msc_sup_dem_entries.
5201 The SCE program will push following order types.
5202 - Purchase Order (Order_Type = 1)
5203 - PO in receiving (Order Type = 8)
5204 - Requisition (Order_Type = 2)
5205 - Intransit Shipment (Order_Type) = 11
5206 */
5207
5208 BEGIN
5209 IF MSC_UTIL.G_MSC_CONFIGURATION = MSC_UTIL.G_CONF_APS_SCE OR
5210 MSC_UTIL.G_MSC_CONFIGURATION = MSC_UTIL.G_CONF_SCE THEN
5211
5212 --MSC_CL_SETUP_ODS_LOAD.GET_COLL_PARAM (pINSTANCE_ID); -- This will initialze the record v_coll_prec
5213
5214 lv_sce_pub_req_id := FND_REQUEST.SUBMIT_REQUEST(
5215 'MSC',
5216 'MSCXPUBO',
5217 NULL, -- description
5218 NULL, -- start date
5219 FALSE, -- sub request,
5220 v_instance_id,
5221 v_current_user,
5222 MSC_UTIL.SYS_YES,
5223 MSC_UTIL.SYS_YES,
5224 MSC_UTIL.SYS_YES,
5225 MSC_UTIL.SYS_YES,
5226 /* CP-ACK starts */
5227 MSC_UTIL.SYS_YES,
5228 /* CP-ACK ends */
5229 MSC_UTIL.SYS_NO, --p_po_sn_flag
5230 MSC_UTIL.SYS_NO, --p_oh_sn_flag
5231 MSC_UTIL.SYS_NO, --p_so_sn_flag
5232 /* CP-AUTO */
5233 MSC_UTIL.SYS_NO --p_suprep_sn_flag
5234 );
5235
5236 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, 'Launched Collaboration ODS Load. Request Id = '||lv_sce_pub_req_id);
5237 END IF;
5238 EXCEPTION WHEN OTHERS THEN
5239 ERRBUF:=SQLERRM||' Request: '||lv_sce_pub_req_id||' Error in Call To program MSCXPUBO ';
5240 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, ERRBUF);
5241 END;
5242
5243 COMMIT;
5244 -----Code changes for APCC refresh-----------
5245 BEGIN
5246
5247
5248 IF (pAPCC_refresh = MSC_UTIL.SYS_YES) THEN
5249 IF (v_is_partial_refresh) THEN
5250 l_req_id := fnd_request.submit_request(
5251 'MSC',
5252 'MSCHUBO',
5253 NULL,
5254 NULL,
5255 FALSE,
5256 pINSTANCE_ID,
5257 2,
5258 NULL);
5259
5260 ELSIF (v_is_complete_refresh) THEN
5261 l_req_id := fnd_request.submit_request(
5262 'MSC',
5263 'MSCHUBO',
5264 NULL,
5265 NULL,
5266 FALSE,
5267 pINSTANCE_ID,
5268 1,
5269 NULL);
5270 END IF;
5271
5272 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, 'Launched APCC refresh data collections CP. Request Id = '||l_req_id);
5273 END IF;
5274 EXCEPTION WHEN OTHERS THEN
5275 ERRBUF:=SQLERRM||' Request: '||l_req_id||' Error in Call To program MSCHUBO ';
5276 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, ERRBUF);
5277 END;
5278
5279 COMMIT;
5280 -----end of changes for APCC refresh----------
5281
5282 /* SCE Change Ends */
5283
5284 -- DELETE SESSION INFO FROM MSC_COLL_PARAMETERS
5285 -- by calling the procedure FINAL
5286
5287 FINAL;
5288
5289 IF RETCODE= MSC_UTIL.G_ERROR THEN
5290
5291 --Rollback swap partitions
5292 IF NOT MSC_CL_EXCHANGE_PARTTBL.UNDO_STG_ODS_SWAP THEN
5293 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR,' Exchange partition failed ');
5294 END IF;
5295
5296 RETURN;
5297 END IF;
5298
5299 IF v_warning_flag=MSC_UTIL.SYS_YES THEN
5300 RETCODE:= MSC_UTIL.G_WARNING;
5301 ELSE
5302 RETCODE := MSC_UTIL.G_SUCCESS ;
5303 END IF;
5304
5305 COMMIT;
5306
5307 EXCEPTION
5308
5309 WHEN EX_PIPE_RCV THEN
5310
5311 ROLLBACK;
5312
5313 IF lv_check_point= 2 THEN
5314 IF SET_ST_STATUS( ERRBUF, RETCODE, pINSTANCE_ID, MSC_UTIL.G_ST_READY) THEN
5315 NULL;
5316 END IF;
5317 END IF;
5318
5319 RETCODE := MSC_UTIL.G_ERROR;
5320 --Rollback swap partitions
5321 IF NOT MSC_CL_EXCHANGE_PARTTBL.UNDO_STG_ODS_SWAP THEN
5322 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR,' Exchange partition failed ');
5323 END IF;
5324
5325 COMMIT;
5326
5327 WHEN EX_PIPE_SND THEN
5328
5329 ROLLBACK;
5330
5331 IF lv_check_point= 2 THEN
5332 IF SET_ST_STATUS( ERRBUF, RETCODE, pINSTANCE_ID, MSC_UTIL.G_ST_READY) THEN
5333 NULL;
5334 END IF;
5335 END IF;
5336
5337 FND_MESSAGE.SET_NAME('MSC', 'MSC_MSG_SEND_FAIL');
5338 FND_MESSAGE.SET_TOKEN('PIPE', v_pipe_wm);
5339 ERRBUF:= FND_MESSAGE.GET;
5340
5341 RETCODE := MSC_UTIL.G_ERROR;
5342 --Rollback swap partitions
5343 IF NOT MSC_CL_EXCHANGE_PARTTBL.UNDO_STG_ODS_SWAP THEN
5344 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR,' Exchange partition failed ');
5345 END IF;
5346
5347 COMMIT;
5348
5349 WHEN EX_PROCESS_TIME_OUT THEN
5350
5351 ROLLBACK;
5352
5353 IF lv_check_point= 2 THEN
5354 IF SET_ST_STATUS( ERRBUF, RETCODE, pINSTANCE_ID, MSC_UTIL.G_ST_READY) THEN
5355 NULL;
5356 END IF;
5357 END IF;
5358
5359 FND_MESSAGE.SET_NAME('MSC', 'MSC_TIMEOUT');
5360 ERRBUF:= FND_MESSAGE.GET;
5361 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, SQLERRM);
5362
5363 RETCODE := MSC_UTIL.G_ERROR;
5364
5365 --Rollback swap partitions
5366 IF NOT MSC_CL_EXCHANGE_PARTTBL.UNDO_STG_ODS_SWAP THEN
5367 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR,' Exchange partition failed ');
5368 END IF;
5369
5370 COMMIT;
5371
5372 WHEN others THEN
5373
5374 ROLLBACK;
5375
5376 IF lv_check_point= 2 THEN
5377 IF SET_ST_STATUS( ERRBUF, RETCODE, pINSTANCE_ID, MSC_UTIL.G_ST_READY) THEN
5378 NULL;
5379 END IF;
5380 END IF;
5381
5382 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, SQLERRM);
5383
5384 ERRBUF := SQLERRM;
5385 RETCODE := MSC_UTIL.G_ERROR;
5386
5387 --Rollback swap partitions
5388 IF NOT MSC_CL_EXCHANGE_PARTTBL.UNDO_STG_ODS_SWAP THEN
5389 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR,' Exchange partition failed ');
5390 END IF;
5391
5392 COMMIT;
5393
5394 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, 'Error_Stack...' );
5395 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, DBMS_UTILITY.FORMAT_ERROR_STACK );
5396 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, 'Error_Backtrace...' );
5397 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, DBMS_UTILITY.FORMAT_ERROR_BACKTRACE );
5398
5399 END LAUNCH_MONITOR;
5400
5401 PROCEDURE DELETE_PROCESS(
5402 ERRBUF OUT NOCOPY VARCHAR2,
5403 RETCODE OUT NOCOPY NUMBER,
5404 pINSTANCE_ID IN NUMBER)
5405 IS
5406 BEGIN
5407
5408 INITIALIZE_LOAD_GLOBALS( pINSTANCE_ID);
5409
5410 DBMS_PIPE.PACK_MESSAGE( UNRESOVLABLE_ERROR);
5411
5412 IF DBMS_PIPE.SEND_MESSAGE( v_pipe_wm)<>0 THEN
5413 FND_MESSAGE.SET_NAME('MSC', 'MSC_MSG_SEND_FAIL');
5414 FND_MESSAGE.SET_TOKEN('PIPE', v_pipe_wm);
5415 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
5416 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, 'DELETER:FAIL TO SEND MESSAGE!');
5417 -- should raise EXCEPTION
5418 END IF;
5419
5420 RETCODE := MSC_UTIL.G_SUCCESS ;
5421
5422 END DELETE_PROCESS;
5423
5424
5425
5426 FUNCTION Q_PARTIAL_TASK (p_instance_id NUMBER,
5427 p_task_num NUMBER)
5428 RETURN BOOLEAN AS
5429
5430 prec MSC_CL_EXCHANGE_PARTTBL.CollParamREC;
5431 PTASK_DEMAND NUMBER;
5432
5433 BEGIN
5434
5435 MSC_CL_SETUP_ODS_LOAD.GET_COLL_PARAM (p_instance_id);
5436
5437 IF (v_coll_prec.app_supp_cap_flag = MSC_UTIL.SYS_YES or v_coll_prec.app_supp_cap_flag = MSC_UTIL.ASL_YES_RETAIN_CP) THEN
5438 IF (p_task_num = PTASK_SUPPLIER_CAPACITY ) THEN
5439 RETURN TRUE;
5440 END IF;
5441 END IF;
5442
5443 IF v_coll_prec.atp_rules_flag = MSC_UTIL.SYS_YES THEN
5444 IF (p_task_num = PTASK_ATP_RULES) THEN
5445 RETURN TRUE;
5446 END IF;
5447 END IF;
5448
5449 IF v_coll_prec.bom_flag = MSC_UTIL.SYS_YES THEN
5450 IF ((p_task_num = PTASK_BOM_COMPONENTS) or
5451 (p_task_num = PTASK_BOM) or
5452 (p_task_num = PTASK_COMPONENT_SUBSTITUTE) or
5453 (p_task_num = PTASK_ROUTING) or
5454 (p_task_num = PTASK_ROUTING_OPERATIONS) or
5455 (p_task_num = PTASK_OPERATION_RESOURCES) or
5456 (p_task_num = PTASK_RESOURCE) or
5457 (p_task_num = PTASK_OP_RESOURCE_SEQ) or
5458 (p_task_num = PTASK_PROCESS_EFFECTIVITY) or
5459 (p_task_num = PTASK_OPERATION_COMPONENTS) or
5460 (p_task_num = PTASK_RESOURCE_SETUP) or /* ds change start */
5461 (p_task_num = PTASK_SETUP_TRANSITION) or
5462 (p_task_num = PTASK_STD_OP_RESOURCES) or /* ds change end */
5463 (p_task_num = PTASK_OPERATION_NETWORKS)) THEN
5464 RETURN TRUE;
5465 END IF;
5466 END IF;
5467
5468 IF v_coll_prec.bor_flag = MSC_UTIL.SYS_YES THEN
5469 IF (p_task_num = PTASK_BOR) THEN
5470 RETURN TRUE;
5471 END IF;
5472 END IF;
5473
5474 IF v_coll_prec.calendar_flag = MSC_UTIL.SYS_YES THEN
5475 IF (p_task_num = PTASK_CALENDAR_DATE OR
5476 (p_task_num = PTASK_BIS_PERIODS )) THEN
5477 RETURN TRUE;
5478 END IF;
5479 END IF;
5480
5481 IF v_coll_prec.demand_class_flag = MSC_UTIL.SYS_YES THEN
5482 IF (p_task_num = PTASK_DEMAND_CLASS) THEN
5483 RETURN TRUE;
5484 END IF;
5485 END IF;
5486
5487 IF v_coll_prec.forecast_flag = MSC_UTIL.SYS_YES THEN
5488 IF ((p_task_num = PTASK_FORECAST_DEMAND) or
5489 -- (p_task_num = PTASK_FORECASTS) or /*This will be done in launch_mon_partial*/
5490 (p_task_num = PTASK_ODS_DEMAND)) THEN
5491 RETURN TRUE;
5492 END IF;
5493 END IF;
5494
5495 IF v_coll_prec.item_flag = MSC_UTIL.SYS_YES THEN
5496 IF ((p_task_num = PTASK_ITEM) or
5497 (p_task_num = PTASK_CATEGORY_ITEM) or
5498 (p_task_num = PTASK_ABC_CLASSES)) THEN
5499 RETURN TRUE;
5500 END IF;
5501 END IF;
5502
5503 IF v_coll_prec.kpi_bis_flag = MSC_UTIL.SYS_YES THEN
5504 IF ((p_task_num = PTASK_BIS_PFMC_MEASURES) OR
5505 (p_task_num = PTASK_BIS_TARGET_LEVELS) OR
5506 (p_task_num = PTASK_BIS_TARGETS ) OR
5507 (p_task_num = PTASK_BIS_BUSINESS_PLANS) ) THEN
5508 RETURN TRUE;
5509 END IF;
5510 END IF;
5511
5512 IF v_coll_prec.mds_flag = MSC_UTIL.SYS_YES THEN
5513 IF ((p_task_num = PTASK_MDS_DEMAND) or
5514 ---- (p_task_num = PTASK_DESIGNATOR) or
5515 ---- Currently LOAD_DESIGNATOR called in the LAUNCH_MONITOR itself.
5516 (p_task_num = PTASK_ODS_DEMAND)) THEN
5517 RETURN TRUE;
5518 END IF;
5519 END IF;
5520
5521 IF v_coll_prec.mps_flag = MSC_UTIL.SYS_YES THEN
5522 IF ((p_task_num = PTASK_SUPPLY)
5523 --- OR (p_task_num = PTASK_DESIGNATOR)
5524 --- Currently LOAD_DESIGNATOR called in the LAUNCH_MONITOR itself.
5525 ) THEN
5526
5527 RETURN TRUE;
5528 END IF;
5529 END IF;
5530
5531 IF ((v_coll_prec.po_flag = MSC_UTIL.SYS_YES) OR
5532 (v_coll_prec.oh_flag = MSC_UTIL.SYS_YES)) THEN
5533 IF (p_task_num = PTASK_SUPPLY) THEN
5534 RETURN TRUE;
5535 END IF;
5536 END IF;
5537
5538 IF v_coll_prec.parameter_flag = MSC_UTIL.SYS_YES THEN
5539 IF (p_task_num = PTASK_PARAMETER) THEN
5540 RETURN TRUE;
5541 END IF;
5542 END IF;
5543
5544 IF v_coll_prec.planner_flag = MSC_UTIL.SYS_YES THEN
5545 IF (p_task_num = PTASK_PLANNERS) THEN
5546 RETURN TRUE;
5547 END IF;
5548 END IF;
5549
5550 IF v_coll_prec.project_flag = MSC_UTIL.SYS_YES THEN
5551 IF (p_task_num = PTASK_PROJECT) THEN
5552 RETURN TRUE;
5553 END IF;
5554 END IF;
5555
5556 IF v_coll_prec.reserves_flag = MSC_UTIL.SYS_YES THEN
5557 IF (p_task_num = PTASK_HARD_RESERVATION) THEN
5558 RETURN TRUE;
5559 END IF;
5560 END IF;
5561
5562 IF (v_coll_prec.resource_nra_flag = MSC_UTIL.SYS_YES OR
5563 v_coll_prec.resource_nra_flag = REGEN_AND_COLLECT) THEN -- BUG 13724715 (FP of 13907513/12955171)
5564 IF (p_task_num = PTASK_NET_RESOURCE_AVAIL) THEN
5565 RETURN TRUE;
5566 END IF;
5567 END IF;
5568
5569 IF v_coll_prec.saf_stock_flag = MSC_UTIL.SYS_YES THEN
5570 IF (p_task_num = PTASK_SAFETY_STOCK) THEN
5571 RETURN TRUE;
5572 END IF;
5573 END IF;
5574
5575 IF v_coll_prec.sales_order_flag = MSC_UTIL.SYS_YES THEN
5576 IF (p_task_num = PTASK_SALES_ORDER) THEN
5577 RETURN TRUE;
5578 END IF;
5579 END IF;
5580
5581 /* NCPerf: always collect SO's in incremental collections */
5582 IF (p_task_num = PTASK_SALES_ORDER) and (v_is_incremental_refresh) THEN
5583 RETURN TRUE;
5584 END IF;
5585
5586
5587 IF v_coll_prec.sourcing_rule_flag = MSC_UTIL.SYS_YES THEN
5588 IF (p_task_num = PTASK_SOURCING) THEN
5589 RETURN TRUE;
5590 END IF;
5591 END IF;
5592
5593 IF v_coll_prec.sub_inventory_flag = MSC_UTIL.SYS_YES THEN
5594 IF (p_task_num = PTASK_SUB_INVENTORY) THEN
5595 RETURN TRUE;
5596 END IF;
5597 END IF;
5598
5599 IF ((v_coll_prec.tp_vendor_flag = MSC_UTIL.SYS_YES) OR
5600 (v_coll_prec.tp_customer_flag = MSC_UTIL.SYS_YES)) THEN
5601 IF (p_task_num = PTASK_TRADING_PARTNER) THEN
5602 RETURN FALSE; -- This will be done in Launch_mon_partial
5603 END IF;
5604 END IF;
5605
5606 IF v_coll_prec.unit_number_flag = MSC_UTIL.SYS_YES THEN
5607 IF (p_task_num = PTASK_UNIT_NUMBER) THEN
5608 RETURN TRUE;
5609 END IF;
5610 END IF;
5611
5612 IF v_coll_prec.uom_flag = MSC_UTIL.SYS_YES THEN
5613 IF (p_task_num = PTASK_UOM) THEN
5614 RETURN FALSE; -- This will be done in Launch_mon_partial
5615 END IF;
5616 END IF;
5617
5618 -- added this task for collecting Prod Subst in targeted collections --
5619 IF v_coll_prec.item_subst_flag = MSC_UTIL.SYS_YES THEN
5620 IF (p_task_num = PTASK_ITEM_SUBSTITUTES) THEN
5621 RETURN TRUE;
5622 END IF;
5623 END IF;
5624
5625 IF v_coll_prec.user_supply_demand_flag = MSC_UTIL.SYS_YES THEN
5626 IF ((p_task_num = PTASK_SUPPLY) or
5627 (p_task_num = PTASK_ODS_DEMAND)) THEN
5628 RETURN TRUE;
5629 END IF;
5630 END IF;
5631
5632 -- QUESTION: What should be the combination of order_type
5633 -- and origination_type for SUPPLY and DEMAND respectively
5634 -- that would be pertinent for USER SUPPLIES and DEMANDS?
5635 -- For example, Is supply order_type = 41 a USER_SUPPLY??
5636 -- or should these be dynamically determined.
5637
5638 IF v_coll_prec.wip_flag = MSC_UTIL.SYS_YES THEN
5639 IF ((p_task_num = PTASK_SUPPLY) or
5640 (p_task_num = PTASK_WIP_RES_REQ) or
5641 (p_task_num = PTASK_RES_INST_REQ) or /* ds change */
5642 (p_task_num = PTASK_WIP_DEMAND ) or
5643 (p_task_num = PTASK_ODS_DEMAND) OR
5644 (p_task_num = PTASK_ODS_RES_REQ) ) THEN
5645 RETURN TRUE;
5646 END IF;
5647 END IF;
5648
5649 IF (v_coll_prec.user_company_flag = MSC_UTIL.COMPANY_ONLY
5650 OR
5651 v_coll_prec.user_company_flag = MSC_UTIL.USER_AND_COMPANY
5652 ) THEN
5653 IF (p_task_num = PTASK_COMPANY_USERS) THEN
5654 RETURN TRUE;
5655 END IF;
5656 END IF;
5657
5658 IF v_coll_prec.supplier_response_flag = MSC_UTIL.SYS_YES THEN
5659 IF (p_task_num = PTASK_SUPPLY) THEN
5660 RETURN TRUE;
5661 END IF;
5662 END IF;
5663 IF (p_task_num = PTASK_ITEM_CUSTOMERS AND v_is_legacy_refresh ) THEN
5664 RETURN TRUE;
5665 END IF;
5666
5667 IF v_coll_prec.trip_flag = MSC_UTIL.SYS_YES THEN
5668 IF (p_task_num = PTASK_TRIP) THEN
5669 RETURN TRUE;
5670 END IF;
5671 END IF;
5672
5673 IF v_coll_prec.sales_channel_flag = MSC_UTIL.SYS_YES THEN
5674 IF (p_task_num = PTASK_SALES_CHANNEL) THEN
5675 RETURN TRUE;
5676 END IF;
5677 END IF;
5678 IF v_coll_prec.fiscal_calendar_flag = MSC_UTIL.SYS_YES THEN
5679 IF (p_task_num = PTASK_FISCAL_CALENDAR) THEN
5680 RETURN TRUE;
5681 END IF;
5682 END IF;
5683 IF v_coll_prec.payback_demand_supply_flag = SYS_YES THEN --bug 5861050
5684 IF (p_task_num = PTASK_PAYBACK_DEMAND_SUPPLY) OR
5685 (p_task_num = PTASK_ODS_DEMAND) OR
5686 (p_task_num = PTASK_SUPPLY) THEN
5687 RETURN TRUE;
5688 END IF;
5689 END IF;
5690
5691 IF v_coll_prec.currency_conversion_flag = MSC_UTIL.SYS_YES THEN ---- for bug # 6469722
5692 IF (p_task_num = PTASK_CURRENCY_CONVERSION) THEN
5693 RETURN TRUE;
5694 END IF;
5695 END IF;
5696
5697 IF v_coll_prec.delivery_details_flag = MSC_UTIL.SYS_YES THEN ---- for bug # 6730983
5698 IF (p_task_num = PTASK_DELIVERY_DETAILS) THEN
5699 RETURN TRUE;
5700 END IF;
5701 END IF;
5702
5703 IF v_coll_prec.internal_repair_flag = MSC_UTIL.SYS_YES THEN
5704 IF ((p_task_num = PTASK_SUPPLY) or
5705 (p_task_num = PTASK_IRO_DEMAND ) or
5706 (p_task_num = PTASK_ODS_DEMAND)) THEN --Changed For Bug 5909379 SRP Additions
5707
5708 RETURN TRUE;
5709 END IF;
5710 END IF;
5711
5712 IF v_coll_prec.external_repair_flag = MSC_UTIL.SYS_YES THEN
5713 IF ((p_task_num = PTASK_SUPPLY) or
5714 (p_task_num = PTASK_ERO_DEMAND ) or
5715 (p_task_num = PTASK_ODS_DEMAND)) THEN --Changed For Bug 5909379 SRP Additions
5716
5717 RETURN TRUE;
5718 END IF;
5719 END IF;
5720 ---- CMRO
5721
5722 IF v_coll_prec.CMRO_flag = MSC_UTIL.SYS_YES THEN
5723 IF ( (p_task_num = PTASK_CMRO) OR
5724 (p_task_num = PTASK_VISITS ) OR
5725 (p_task_num = PTASK_WO_ATTRIBUTES ) OR
5726 (p_task_num = PTASK_WO_TASK_HIERARCHY ) OR
5727 (p_task_num = PTASK_WO_OPERATION_REL ) OR
5728 (p_task_num = PTASK_WORK_BREAKDOWN_STRUCT ) OR
5729 (p_task_num = PTASK_WO_MILESTONES ) OR
5730 (p_task_num = PTASK_WO_SUB_COMP ) OR
5731 (p_task_num = PTASK_CMRO_SUPP_RESRV )
5732 ) THEN
5733 RETURN TRUE;
5734 END IF;
5735 END IF;
5736 /* USAF */
5737 IF v_coll_prec.cmro_forecasts_flag = MSC_UTIL.SYS_YES THEN
5738 IF ((p_task_num = PTASK_SUPPLY) OR
5739 (p_task_num = PTASK_CMRO_FORECAST_DEMANDS) OR
5740 (p_task_num = PTASK_CMRO_FORECAST_RR) or
5741 (p_task_num = PTASK_ODS_DEMAND) OR
5742 (p_task_num = PTASK_ODS_RES_REQ) )
5743 THEN
5744 RETURN TRUE;
5745 END IF;
5746 END IF;
5747
5748 IF v_coll_prec.eAM_info_flag = MSC_UTIL.SYS_YES THEN
5749 IF (p_task_num = PTASK_EAM_INFO) THEN
5750 RETURN TRUE;
5751 END IF;
5752 END IF;
5753
5754 IF v_coll_prec.eAM_forecasts_flag = MSC_UTIL.SYS_YES THEN
5755 IF ((p_task_num = PTASK_EAM_FORECAST) OR
5756 (p_task_num = PTASK_EAM_FORECAST_DEMANDS) OR
5757 (p_task_num = PTASK_EAM_FORECAST_RR) or
5758 (p_task_num = PTASK_ODS_DEMAND) or
5759 (p_task_num = PTASK_ODS_RES_REQ) or
5760 (p_task_num = PTASK_SUPPLY)) THEN
5761 RETURN TRUE;
5762 END IF;
5763 END IF;
5764 /* USAF */
5765
5766 IF v_coll_prec.cmro_closed_wo = MSC_UTIL.SYS_YES THEN
5767 IF (p_task_num = PTASK_CMRO_CLOSED_WO) THEN
5768 RETURN TRUE;
5769 END IF;
5770 END IF;
5771
5772 IF v_coll_prec.osp_supply = MSC_UTIL.SYS_YES THEN
5773 IF (p_task_num = PTASK_OSP_SUPPLY) THEN
5774 RETURN TRUE;
5775 END IF;
5776 END IF;
5777
5778
5779 IF v_coll_prec.ibuc_history_flag = MSC_UTIL.SYS_YES THEN
5780 IF (p_task_num = PTASK_IBUC_HISTORY) THEN
5781 RETURN TRUE;
5782 END IF;
5783 END IF;
5784
5785 IF v_coll_prec.notes_attach_flag = MSC_UTIL.SYS_YES THEN
5786 IF ((p_task_num = PTASK_SHORT_TEXT) OR (p_task_num = PTASK_LONG_TEXT) )THEN
5787 RETURN TRUE;
5788 END IF;
5789
5790 END IF;
5791 -- Note that there is no PTASK_STAGING_DEMAND that is
5792 -- used but there is PTASK_STAGING_SUPPLY task being used.
5793 -- since there are already several procs that load from
5794 -- staging to ODS demand table.
5795 -- PTASK_SUPPLY encompases both PTASK_STAGING_SUPPLY
5796 -- and PTASK_ODS_SUPPLY.
5797
5798 RETURN FALSE;
5799
5800 END Q_PARTIAL_TASK;
5801
5802
5803 /* procedure LOAD_ODS_DEMAND has been moved to package MSC_CL_DEMAND_ODS_LOAD
5804 through bug5952569 */
5805
5806
5807
5808 PROCEDURE LAUNCH_MON_PARTIAL(
5809 ERRBUF OUT NOCOPY VARCHAR2,
5810 RETCODE OUT NOCOPY NUMBER,
5811 pINSTANCE_ID IN NUMBER,
5812 pTIMEOUT IN NUMBER,-- minutes
5813 pTotalWorkerNum IN NUMBER,
5814 pRECALC_NRA IN NUMBER,
5815 pRECALC_SH IN NUMBER,
5816 pPURGE_SH IN NUMBER, --to delete Sourcing History
5817 pAPCC_refresh IN NUMBER DEFAULT MSC_UTIL.SYS_NO) IS
5818
5819 lc_i PLS_INTEGER;
5820 lv_task_number NUMBER;
5821 lv_task_not_completed NUMBER := 0;
5822
5823 lv_process_time NUMBER;
5824 lv_bon_start_end_partial NUMBER;
5825
5826 EX_PIPE_RCV EXCEPTION;
5827 EX_PIPE_SND EXCEPTION;
5828 EX_PROCESS_TIME_OUT EXCEPTION;
5829
5830 lv_pipe_ret_code NUMBER;
5831
5832 lv_check_point NUMBER := 0;
5833
5834 lvs_request_id NumTblTyp := NumTblTyp(0);
5835
5836 lv_worker_committed NUMBER;
5837
5838 lv_delete_flag NUMBER;
5839
5840 lv_start_time DATE;
5841
5842 lv_collection_plan_exists NUMBER;
5843
5844 lv_sql_stmt VARCHAR2(5000);
5845
5846 lv_dblink VARCHAR2(128);
5847
5848 lv_RECALC_NRA NUMBER;
5849 lv_refresh_so number;
5850 lv_refresh_sd number;
5851 /* ATP SUMMARY CHANGES */
5852 lv_atp_package_exists number;
5853 lv_inv_ctp number;
5854 lv_MSC_ENABLE_ATP_SUMMARY number;
5855 lv_atp_request_id number;
5856
5857 lv_debug_retcode number;
5858
5859 lv_ret_res_ava number;
5860
5861 lv_apps_schema varchar2(32);
5862 lv_read_only_flag varchar2(32);
5863
5864
5865 CURSOR c_query_package is
5866 SELECT 1
5867 FROM ALL_SOURCE
5868 WHERE NAME = 'MSC_POST_PRO'
5869 AND TYPE = 'PACKAGE BODY'
5870 AND OWNER = lv_apps_schema
5871 AND ROWNUM<2;
5872
5873 /* ATP SUMMARY CHANGES END*/
5874
5875 /* SCE changes starts */
5876 lv_sce_pub_req_id NUMBER;
5877 lv_process_comp_err NUMBER;
5878 /* SCE changes ends */
5879 l_req_id NUMBER;
5880
5881 BEGIN
5882
5883 p_TIMEOUT := pTIMEOUT;
5884 lv_read_only_flag:='U';
5885 BEGIN
5886 select oracle_username
5887 into lv_apps_schema
5888 from fnd_oracle_userid where
5889 read_only_flag = lv_read_only_flag;
5890 EXCEPTION
5891 WHEN OTHERS THEN
5892 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, SQLERRM);
5893 END;
5894
5895
5896 /* Carry out things such as creating temp tables
5897 // Creating Unique Indexes etc.
5898 // Use the same methods that are used in Launch_Monitor.
5899 */
5900
5901 /* NOTE that all temporory tables are created.
5902 // Only those tables that have partial replacement data
5903 // loaded will be exchanged.
5904 */
5905
5906 v_prec_defined := FALSE;
5907
5908 -- ============== Create Temproray Tables ====================
5909 v_exchange_mode:= MSC_UTIL.SYS_NO;
5910 v_so_exchange_mode:= MSC_UTIL.SYS_NO;
5911
5912 -- agmcont:
5913 -- move this from below
5914 MSC_CL_SETUP_ODS_LOAD.GET_COLL_PARAM (pINSTANCE_ID, v_coll_prec);
5915
5916 if (v_is_cont_refresh) then
5917 -- set so refresh flags
5918 if (v_coll_prec.so_sn_flag = MSC_UTIL.SYS_INCR) then
5919 v_is_so_complete_refresh := FALSE;
5920 v_is_so_incremental_refresh := TRUE;
5921 elsif (v_coll_prec.so_sn_flag = MSC_UTIL.SYS_TGT) then
5922 v_is_so_complete_refresh := TRUE;
5923 v_is_so_incremental_refresh := FALSE;
5924 else
5925 v_is_so_complete_refresh := FALSE;
5926 v_is_so_incremental_refresh := FALSE;
5927 end if;
5928 end if;
5929
5930 --==================================================================
5931 -- NCP: Temporary tables need to be created for Partial refresh only.
5932 -- In case of Net change, temporary tables will not be created.
5933 --==================================================================
5934
5935 if v_is_incremental_refresh then null;
5936 else
5937
5938 -- agmcont
5939 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, ' CREATE PARTITIONS ');
5940 IF (v_is_partial_refresh or v_is_cont_refresh) AND
5941 is_msctbl_partitioned('MSC_SYSTEM_ITEMS') AND
5942 MSC_CL_EXCHANGE_PARTTBL.Initialize( v_instance_id,
5943 v_instance_code,
5944 v_is_so_complete_refresh) THEN
5945 IF MSC_CL_EXCHANGE_PARTTBL.Create_Temp_Tbl THEN
5946 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, ' CREATE TEMP TABLES DONE ');
5947 v_exchange_mode:= MSC_UTIL.SYS_YES;
5948
5949 IF v_is_so_complete_refresh THEN
5950 v_so_exchange_mode:= MSC_UTIL.SYS_YES;
5951 END IF;
5952
5953 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, ' Exchange Mode = '||v_exchange_mode);
5954
5955 ELSE
5956 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, ERRBUF);
5957 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, SQLERRM);
5958 IF SET_ST_STATUS( ERRBUF, RETCODE, pINSTANCE_ID, MSC_UTIL.G_ST_READY) THEN
5959 COMMIT;
5960 END IF;
5961
5962 RETCODE := MSC_UTIL.G_ERROR;
5963
5964 RETURN;
5965 END IF; -- end Create_Temp_Tbl
5966
5967 ELSE
5968 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, ERRBUF);
5969 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, SQLERRM);
5970 IF SET_ST_STATUS( ERRBUF, RETCODE, pINSTANCE_ID, MSC_UTIL.G_ST_READY) THEN
5971 COMMIT;
5972 END IF;
5973
5974 RETCODE := MSC_UTIL.G_ERROR;
5975
5976 RETURN;
5977 END IF; -- end partial refresh , is_msctbl_partitioned and initialize
5978 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, ' CREATE PARTITIONS DONE ');
5979
5980 end if;
5981
5982 -- agmcont:
5983 -- move this above
5984 -- GET_COLL_PARAM (pINSTANCE_ID, v_coll_prec);
5985
5986 -- agmcont
5987
5988 /* SCE CHANGE starts*/
5989 -- =============================================
5990 -- Change the company name in msc_companies and
5991 -- msc_trading_partners if it is cheanged in
5992 -- MSC : Operator Company Name profile option.
5993 -- =============================================
5994
5995 IF (MSC_UTIL.G_MSC_CONFIGURATION = MSC_UTIL.G_CONF_APS_SCE
5996 OR MSC_UTIL.G_MSC_CONFIGURATION = MSC_UTIL.G_CONF_SCE) THEN
5997
5998 MSC_CL_SCE_COLLECTION.PROCESS_COMPANY_CHANGE(lv_process_comp_err);
5999
6000 if (lv_process_comp_err = MSC_UTIL.G_ERROR) THEN
6001 ROLLBACK;
6002 IF SET_ST_STATUS( ERRBUF, RETCODE, pINSTANCE_ID, MSC_UTIL.G_ST_READY) THEN
6003 COMMIT;
6004 END IF;
6005
6006 RETCODE := MSC_UTIL.G_ERROR;
6007 RETURN;
6008 end if;
6009 END IF;
6010
6011 -- ========== Get My Company Name ============
6012 --IF (G_MSC_CONFIGURATION = G_CONF_APS_SCE OR G_MSC_CONFIGURATION = G_CONF_SCE) THEN
6013 v_my_company_name := MSC_CL_SCE_COLLECTION.GET_MY_COMPANY;
6014
6015 IF (v_my_company_name = null) then
6016 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, 'Error while fetching Company Name');
6017 ROLLBACK;
6018 IF SET_ST_STATUS( ERRBUF, RETCODE, pINSTANCE_ID, MSC_UTIL.G_ST_READY) THEN
6019 COMMIT;
6020 END IF;
6021 RETCODE := MSC_UTIL.G_ERROR;
6022 RETURN;
6023 END IF;
6024 --END IF;
6025 /* SCE CHANGE ends*/
6026
6027 -- =========== Data Cleansing =================
6028
6029 /* SCE Debug */
6030 FND_MESSAGE.SET_NAME('MSC', 'MSC_X_SHOW_CONFIG');
6031 FND_MESSAGE.SET_TOKEN('NAME', MSC_UTIL.G_MSC_CONFIGURATION);
6032 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
6033
6034 FND_MESSAGE.SET_NAME('MSC', 'MSC_X_SHOW_COMPANY');
6035 FND_MESSAGE.SET_TOKEN('NAME', v_my_company_name);
6036 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
6037
6038 /* Following step does the data cleanup in staging tables and creates
6039 global Ids for Trading Partner and Items.
6040
6041 If MSC:Configuration = 'APS' then
6042 - Execute MSC_CL_SETUP_ODS_LOAD.CLEANSE_DATA (Hook for Customization)
6043 - TRANSFORM KEYS
6044
6045 If MSC:Configuration = 'APS+SCE' or 'SCE' then
6046 - Execute MSC_CL_SETUP_ODS_LOAD.CLEANSE_DATA (Hook for Customization)
6047 - MSC_CL_SCE_COLLECTION.CLEANSE_DATA_FOR_SCE (Data cleanup for Multi Company)
6048 - MSC_CL_SCE_COLLECTION.SCE_TRANSFORM_KEYS (New Companies and Sites in Collaboration area)
6049 - TRANSFORM KEYS (Global Ids for Trading Partners in Planning Area)
6050 */
6051
6052 /* added code to call cleanse Data when Targeted Collections is running */
6053
6054 IF MSC_CL_SETUP_ODS_LOAD.CLEANSE_DATA THEN
6055
6056 COMMIT;
6057
6058 ELSE
6059 FND_MESSAGE.SET_NAME('MSC','MSC_CL_TRANSFORM_KEY_ERR');
6060 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
6061 ROLLBACK;
6062
6063 FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_DC_FAIL');
6064 ERRBUF:= FND_MESSAGE.GET;
6065 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, ERRBUF);
6066 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, SQLERRM);
6067
6068 IF SET_ST_STATUS( ERRBUF, RETCODE, pINSTANCE_ID, MSC_UTIL.G_ST_READY) THEN
6069 COMMIT;
6070 END IF;
6071
6072 RETCODE := MSC_UTIL.G_ERROR;
6073
6074 RETURN;
6075
6076 END IF;
6077
6078 -- Data Cleansing and Transform_KEYS is called in Launch_Mon_Partial
6079 -- only when ITEM or TRADING PARTNER information is Loaded.
6080 IF ((v_coll_prec.item_flag = MSC_UTIL.SYS_YES) OR
6081 (v_coll_prec.tp_vendor_flag = MSC_UTIL.SYS_YES) OR
6082 (v_coll_prec.tp_customer_flag = MSC_UTIL.SYS_YES) OR
6083 (v_coll_prec.sourcing_rule_flag = MSC_UTIL.SYS_YES AND v_is_incremental_refresh=FALSE) ) THEN
6084
6085 IF (MSC_UTIL.G_MSC_CONFIGURATION = MSC_UTIL.G_CONF_APS_SCE OR MSC_UTIL.G_MSC_CONFIGURATION = MSC_UTIL.G_CONF_SCE) THEN
6086 IF /* SCE CHANGE starts */
6087 /* Data cleanup based on MSC:Configuration profile option */
6088 MSC_CL_SCE_COLLECTION.CLEANSE_DATA_FOR_SCE(v_instance_id,
6089 v_my_company_name)
6090 AND MSC_CL_SCE_COLLECTION.SCE_TRANSFORM_KEYS(v_instance_id,
6091 v_current_user,
6092 v_current_date,
6093 v_last_collection_id,
6094 v_is_incremental_refresh,
6095 v_is_complete_refresh,
6096 v_is_partial_refresh,
6097 v_is_cont_refresh,
6098 v_coll_prec.tp_vendor_flag,
6099 v_coll_prec.tp_customer_flag)
6100
6101 /* SCE CHANGE ends */
6102
6103 AND MSC_CL_SETUP_ODS_LOAD.TRANSFORM_KEYS THEN
6104
6105 COMMIT;
6106
6107 ELSE
6108
6109 ROLLBACK;
6110
6111 FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_DC_FAIL');
6112 ERRBUF:= FND_MESSAGE.GET;
6113
6114 IF SET_ST_STATUS( ERRBUF, RETCODE, pINSTANCE_ID, MSC_UTIL.G_ST_READY) THEN
6115 COMMIT;
6116 END IF;
6117
6118 RETCODE := MSC_UTIL.G_ERROR;
6119
6120 RETURN;
6121
6122 END IF;
6123
6124
6125 ELSIF MSC_UTIL.G_MSC_CONFIGURATION = MSC_UTIL.G_CONF_APS THEN
6126
6127 IF MSC_CL_SETUP_ODS_LOAD.TRANSFORM_KEYS THEN
6128 -- IF MSC_CL_SETUP_ODS_LOAD.CLEANSE_DATA AND MSC_CL_SETUP_ODS_LOAD.TRANSFORM_KEYS THEN
6129 -- Do we do the CLEANSE of DATA or not for Partial replacement.
6130
6131 COMMIT;
6132
6133 ELSE
6134
6135 ROLLBACK;
6136
6137 FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_DC_FAIL');
6138 ERRBUF:= FND_MESSAGE.GET;
6139
6140 IF SET_ST_STATUS( ERRBUF, RETCODE, pINSTANCE_ID, MSC_UTIL.G_ST_READY) THEN
6141 COMMIT;
6142 END IF;
6143
6144 RETCODE := MSC_UTIL.G_ERROR;
6145
6146 RETURN;
6147
6148 END IF;
6149 END IF;
6150
6151 END IF;
6152
6153 -- ============ Load Orgnization, Designator, UOM - same as in launch_monitor==============
6154 /* load trading_partner first to provide organization_code information */
6155 IF ((v_coll_prec.tp_vendor_flag = MSC_UTIL.SYS_YES) OR
6156 (v_coll_prec.tp_customer_flag = MSC_UTIL.SYS_YES)) THEN
6157
6158 --agmcont
6159 if (v_is_cont_refresh) then
6160 -- do net-change for this entity
6161 v_is_incremental_refresh := TRUE;
6162 v_is_partial_refresh := FALSE;
6163 end if;
6164
6165 if (v_is_partial_refresh) then
6166 MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'update so_tbl status to no');
6167 UPDATE MSC_APPS_INSTANCES mai
6168 SET
6169 so_tbl_status= MSC_UTIL.SYS_NO,
6170 LAST_UPDATE_DATE= v_current_date,
6171 LAST_UPDATED_BY= v_current_user,
6172 REQUEST_ID= FND_GLOBAL.CONC_REQUEST_ID
6173 WHERE mai.INSTANCE_ID= v_instance_id;
6174 commit;
6175 end if;
6176
6177 FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
6178 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SETUP_ODS_LOAD.LOAD_TRADING_PARTNER');
6179 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
6180 MSC_CL_SETUP_ODS_LOAD.LOAD_TRADING_PARTNER;
6181
6182 /* SCE Change starts */
6183 /* By this time Trading Partners , Organizations are loaded into planning area as well as collaboration area. Now we can populate the
6184 msc_trading_partner_maps table.
6185 Perform this step if the profile option is 'APS + SCE' OR 'SCE'.
6186 */
6187 IF MSC_UTIL.G_MSC_CONFIGURATION = MSC_UTIL.G_CONF_APS_SCE OR
6188 MSC_UTIL.G_MSC_CONFIGURATION = MSC_UTIL.G_CONF_SCE THEN
6189 FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
6190 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SCE_COLLECTION.POPULATE_TP_MAP_TABLE');
6191 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
6192 MSC_CL_SCE_COLLECTION.POPULATE_TP_MAP_TABLE(v_instance_id);
6193 END IF;
6194 -- END IF;
6195
6196 /* SCE Change ends */
6197
6198 if (v_is_partial_refresh AND v_coll_prec.sourcing_rule_flag = MSC_UTIL.SYS_NO AND v_coll_prec.atp_rules_flag = MSC_UTIL.SYS_NO) then
6199 UPDATE MSC_APPS_INSTANCES mai
6200 SET
6201 so_tbl_status= MSC_UTIL.SYS_YES,
6202 LAST_UPDATE_DATE= v_current_date,
6203 LAST_UPDATED_BY= v_current_user,
6204 REQUEST_ID= FND_GLOBAL.CONC_REQUEST_ID
6205 WHERE mai.INSTANCE_ID= v_instance_id;
6206 commit;
6207 end if;
6208 END IF;
6209
6210 COMMIT;
6211
6212 /* Load parameters in the Main ODS Load so that this information is available to the function
6213 CALC_RESOURCE_AVAILABILITY called within LOAD_CALENDAR_DATE */
6214
6215 IF v_coll_prec.parameter_flag = MSC_UTIL.SYS_YES THEN
6216
6217 FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
6218 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SETUP_ODS_LOAD.LOAD_PARAMETER');
6219 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
6220 MSC_CL_SETUP_ODS_LOAD.LOAD_PARAMETER;
6221 END IF;
6222
6223 COMMIT;
6224
6225 /* load schedule to provide schedule designator information */
6226 /* NOTE However that Partial Refresh loads schedule info into
6227 // staging tables only for MDS and MPS cases. Alternatively
6228 // this can be called as a separate task through
6229 // EXECUTE_PARTIAL_TASK which is currently disabled.
6230 */
6231 /* load schedule to provide schedule designator information */
6232
6233 IF (v_coll_prec.mds_flag = MSC_UTIL.SYS_YES) OR (v_coll_prec.mps_flag = MSC_UTIL.SYS_YES) THEN
6234
6235
6236 -- agmcont
6237 if (v_is_cont_refresh) then
6238 v_is_incremental_refresh := TRUE;
6239 v_is_partial_refresh := FALSE;
6240 end if;
6241
6242 FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
6243 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LOAD_DESIGNATOR');
6244 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
6245 MSC_CL_DEMAND_ODS_LOAD.LOAD_DESIGNATOR;
6246
6247 COMMIT;
6248
6249 END IF;
6250
6251 /* load Forecast Designator to provide */
6252 IF (v_coll_prec.forecast_flag = MSC_UTIL.SYS_YES OR v_coll_prec.ret_fcst_flag
6253 = MSC_UTIL.SYS_YES) THEN -- 13839374 added ret_fcst
6254
6255 -- agmcont
6256 if (v_is_cont_refresh) then
6257 v_is_incremental_refresh := TRUE;
6258 v_is_partial_refresh := FALSE;
6259 end if;
6260
6261 FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
6262 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LOAD_FORECASTS');
6263 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
6264 MSC_CL_DEMAND_ODS_LOAD.LOAD_FORECASTS;
6265
6266 END IF;
6267
6268 /* USAF load eam-CMRO designators */
6269
6270 IF (v_apps_ver >= MSC_UTIL.G_EAM_CMRO_SUP_VER
6271 AND MSC_UTIL.G_CMRO_EAM_INT_ENABLED = 'Y' ) THEN
6272
6273 FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
6274 FND_MESSAGE.SET_TOKEN('PROCEDURE',
6275 'MSC_CL_DEMAND_ODS_LOAD.LOAD_CMRO_EAM_FORECASTS');
6276 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
6277 MSC_CL_DEMAND_ODS_LOAD.LOAD_CMRO_EAM_FORECASTS ;
6278 COMMIT;
6279
6280 END IF;
6281
6282 /* load unit of measure */
6283 IF v_coll_prec.uom_flag = MSC_UTIL.SYS_YES THEN
6284
6285 -- agmcont
6286 if (v_is_cont_refresh) then
6287 v_is_incremental_refresh := TRUE;
6288 v_is_partial_refresh := FALSE;
6289 end if;
6290
6291 FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
6292 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SETUP_ODS_LOAD.LOAD_UOM');
6293 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
6294 MSC_CL_SETUP_ODS_LOAD.LOAD_UOM;
6295
6296 COMMIT;
6297
6298 END IF;
6299
6300 /* CP-ACK starts */
6301 -- ============================================================
6302 -- We will also load Calendar Dates as Set up entity.
6303 -- We need to do these changes since CP code refers to Calendar
6304 -- ============================================================
6305 IF v_coll_prec.calendar_flag = MSC_UTIL.SYS_YES THEN
6306
6307 if (v_is_cont_refresh) then
6308 v_is_incremental_refresh := TRUE;
6309 v_is_partial_refresh := FALSE;
6310 end if;
6311
6312 FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
6313 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_SETUP_ODS_LOAD.LOAD_CALENDAR_SET_UP');
6314 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
6315 MSC_CL_SETUP_ODS_LOAD.LOAD_CALENDAR_SET_UP;
6316
6317 END IF;
6318
6319 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, 'LAUNCH_MON_PARTIAL: Deleting MSC_NET_RESOURCE_AVAIL...');
6320
6321 IF (v_instance_type <> MSC_UTIL.G_INS_OTHER) AND
6322 (v_is_complete_refresh OR
6323 (v_is_partial_refresh AND
6324 (v_coll_prec.resource_nra_flag = MSC_UTIL.SYS_YES OR -- BUG 13724715 (FP of bug 13907513)
6325 v_coll_prec.resource_nra_flag = REGEN_AND_COLLECT))) THEN
6326 IF v_coll_prec.org_group_flag = MSC_UTIL.G_ALL_ORGANIZATIONS THEN
6327 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, 'debug-05');
6328 DELETE_MSC_TABLE( 'MSC_NET_RESOURCE_AVAIL', v_instance_id, -1);
6329 DELETE_MSC_TABLE( 'MSC_NET_RES_INST_AVAIL', v_instance_id, -1);
6330 ELSE
6331 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, 'debug-06');
6332 v_sub_str :=' AND ORGANIZATION_ID '||MSC_UTIL.v_in_org_str;
6333 DELETE_MSC_TABLE( 'MSC_NET_RESOURCE_AVAIL', v_instance_id, -1,v_sub_str);
6334 DELETE_MSC_TABLE( 'MSC_NET_RES_INST_AVAIL', v_instance_id, -1,v_sub_str);
6335 END IF;
6336
6337 END IF;
6338
6339
6340 IF NOT (v_is_cont_refresh) then
6341 -- ============ Launch the Workers here ==============
6342
6343 lvs_request_id.EXTEND( pTotalWorkerNum);
6344
6345 IF v_cp_enabled= MSC_UTIL.SYS_YES THEN
6346
6347 FOR lc_i IN 1..pTotalWorkerNum LOOP
6348 lvs_request_id(lc_i) := FND_REQUEST.SUBMIT_REQUEST(
6349 'MSC',
6350 'MSCPDCW',
6351 NULL, -- description
6352 NULL, -- start date
6353 FALSE, -- TRUE,
6354 FND_GLOBAL.CONC_REQUEST_ID,
6355 pINSTANCE_ID,
6356 v_last_collection_id,
6357 pTIMEOUT,
6358 pRECALC_NRA,
6359 pRECALC_SH,
6360 v_exchange_mode,
6361 v_so_exchange_mode);
6362
6363 COMMIT;
6364
6365 IF lvs_request_id(lc_i)= 0 THEN
6366
6367 ROLLBACK;
6368
6369 IF SET_ST_STATUS( ERRBUF, RETCODE, pINSTANCE_ID, MSC_UTIL.G_ST_READY) THEN
6370 COMMIT;
6371 END IF;
6372
6373 FOR lc_i IN 1..pTotalWorkerNum LOOP
6374
6375 DBMS_PIPE.PACK_MESSAGE( -1);
6376
6377 IF DBMS_PIPE.SEND_MESSAGE( v_pipe_task_que)<>0 THEN
6378 RAISE EX_PIPE_SND;
6379 END IF;
6380
6381 FND_MESSAGE.SET_NAME('MSC','MSC_CL_SEND_WOR_END');
6382 FND_MESSAGE.SET_TOKEN('LCI',lc_i);
6383 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
6384
6385 END LOOP;
6386
6387 FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_LAUNCH_WORKER_FAIL');
6388 ERRBUF:= FND_MESSAGE.GET;
6389 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, ERRBUF);
6390
6391 RETCODE := MSC_UTIL.G_ERROR;
6392
6393 -- DELETE SESSION INFO FROM MSC_COLL_PARAMETERS
6394 -- by calling the procedure FINAL
6395
6396 FINAL;
6397
6398 COMMIT;
6399
6400 RETURN;
6401 ELSE
6402 FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_WORKER_REQUEST_ID');
6403 FND_MESSAGE.SET_TOKEN('REQUEST_ID', lvs_request_id(lc_i));
6404 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
6405 END IF;
6406
6407 END LOOP;
6408
6409 ELSE
6410 COMMIT;
6411
6412 END IF; -- v_cp_enabled
6413 ELSE
6414
6415 NULL;
6416 /* for cont. collections the ODS load workers
6417 are launched from the MSCCLFAB.pls */
6418
6419 END IF;
6420 msc_util.print_trace_file_name(FND_GLOBAL.CONC_REQUEST_ID);
6421
6422 -- ============ Send Tasks to Task Que 'v_pipe_task_que' =============
6423 -- load sales orders will be called from load_supply - link demand-supply
6424
6425 --bug3954345. Setting so_tbl_status to 2 so that ATP inquiry dosent go through
6426 --unless all the related ATP tables are populated
6427
6428 MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'update so_tbl status to no');
6429 if (v_is_partial_refresh AND ((v_coll_prec.sourcing_rule_flag = MSC_UTIL.SYS_YES OR v_coll_prec.atp_rules_flag = MSC_UTIL.SYS_YES)
6430 AND (v_coll_prec.tp_vendor_flag = MSC_UTIL.SYS_NO AND v_coll_prec.tp_customer_flag = MSC_UTIL.SYS_NO))) then
6431 UPDATE MSC_APPS_INSTANCES mai
6432 SET
6433 so_tbl_status= MSC_UTIL.SYS_NO,
6434 LAST_UPDATE_DATE= v_current_date,
6435 LAST_UPDATED_BY= v_current_user,
6436 REQUEST_ID= FND_GLOBAL.CONC_REQUEST_ID
6437 WHERE mai.INSTANCE_ID= v_instance_id;
6438 commit;
6439 end if;
6440
6441 FOR lc_i IN 1..TOTAL_PARTIAL_TASKS LOOP
6442 -- Determine whether the task has to be executed or not.
6443
6444 IF Q_PARTIAL_TASK (pINSTANCE_ID, lc_i) THEN
6445
6446 IF (MSC_UTIL.G_MSC_DEBUG <> 'N' ) THEN
6447 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, 'PIPE to the ODS LOAD - Task Number ' || TO_CHAR(lc_i));
6448 END IF;
6449 DBMS_PIPE.PACK_MESSAGE( lc_i);
6450 MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'Sending task number: '||lc_i||' to the queue');
6451
6452 IF DBMS_PIPE.SEND_MESSAGE( v_pipe_task_que)<>0 THEN
6453
6454 FND_MESSAGE.SET_NAME('MSC','MSC_CL_ERROR_SEND_TSK');
6455 FND_MESSAGE.SET_TOKEN('LCI',lc_i);
6456 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
6457
6458 RAISE EX_PIPE_SND;
6459 END IF;
6460
6461 lv_task_not_completed := lv_task_not_completed + 1;
6462 END IF;
6463 END LOOP;
6464
6465 DBMS_LOCK.SLEEP( 5); -- initial estimated sleep time
6466
6467 --lv_task_not_completed := TOTAL_PARTIAL_TASKS;
6468
6469 -- Now monitor the performance of the tasks.
6470 lv_bon_start_end_partial :=0;
6471
6472 LOOP
6473
6474 var_debug := 1;
6475 EXIT WHEN lv_task_not_completed = 0;
6476
6477 var_debug := 2;
6478 EXIT WHEN is_request_status_running <> MSC_UTIL.SYS_YES;
6479
6480 var_debug := 3;
6481 EXIT WHEN is_worker_status_valid(lvs_request_id) <> MSC_UTIL.SYS_YES;
6482
6483 lv_pipe_ret_code:= DBMS_PIPE.RECEIVE_MESSAGE( v_pipe_wm, PIPE_TIME_OUT);
6484 MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'Pipe Return code: '||lv_pipe_ret_code);
6485
6486 IF lv_pipe_ret_code=0 THEN
6487
6488 DBMS_PIPE.UNPACK_MESSAGE( lv_task_number);
6489 MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'Unpacked Task Number : '||lv_task_number);
6490
6491 if lv_task_number = PTASK_ATP_RULES THEN
6492 G_TASK_ATP_RULES :=1;
6493 elsif lv_task_number = PTASK_SOURCING THEN
6494 G_TASK_SOURCING :=1;
6495 elsif lv_task_number = PTASK_ROUTING THEN
6496 lv_bon_start_end_partial := lv_bon_start_end_partial + 1;
6497 elsif lv_task_number = PTASK_OPERATION_NETWORKS THEN
6498 lv_bon_start_end_partial := lv_bon_start_end_partial + 1;
6499 elsif lv_task_number = PTASK_ROUTING_OPERATIONS THEN
6500 lv_bon_start_end_partial := lv_bon_start_end_partial + 1;
6501 end if;
6502
6503 if v_is_partial_refresh AND (v_coll_prec.sourcing_rule_flag = MSC_UTIL.SYS_YES AND v_coll_prec.atp_rules_flag = MSC_UTIL.SYS_YES) then
6504 if G_TASK_ATP_RULES =1 and G_TASK_SOURCING =1 then
6505 UPDATE MSC_APPS_INSTANCES mai
6506 SET
6507 so_tbl_status= MSC_UTIL.SYS_YES,
6508 LAST_UPDATE_DATE= v_current_date,
6509 LAST_UPDATED_BY= v_current_user,
6510 REQUEST_ID= FND_GLOBAL.CONC_REQUEST_ID
6511 WHERE mai.INSTANCE_ID= v_instance_id;
6512 MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'update so tbl status');
6513 commit;
6514 G_TASK_ATP_RULES:=0;
6515 G_TASK_SOURCING :=0;
6516 end if;
6517 elsif v_is_partial_refresh AND (v_coll_prec.sourcing_rule_flag = MSC_UTIL.SYS_YES AND v_coll_prec.atp_rules_flag = MSC_UTIL.SYS_NO) then
6518 if G_TASK_SOURCING =1 then
6519 UPDATE MSC_APPS_INSTANCES mai
6520 SET
6521 so_tbl_status= MSC_UTIL.SYS_YES,
6522 LAST_UPDATE_DATE= v_current_date,
6523 LAST_UPDATED_BY= v_current_user,
6524 REQUEST_ID= FND_GLOBAL.CONC_REQUEST_ID
6525 WHERE mai.INSTANCE_ID= v_instance_id;
6526 MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'update so tbl status');
6527 commit;
6528 G_TASK_SOURCING :=0;
6529 end if;
6530 elsif v_is_partial_refresh AND (v_coll_prec.sourcing_rule_flag = MSC_UTIL.SYS_NO AND v_coll_prec.atp_rules_flag = MSC_UTIL.SYS_YES) then
6531 if G_TASK_ATP_RULES =1 then
6532 UPDATE MSC_APPS_INSTANCES mai
6533 SET
6534 so_tbl_status= MSC_UTIL.SYS_YES,
6535 LAST_UPDATE_DATE= v_current_date,
6536 LAST_UPDATED_BY= v_current_user,
6537 REQUEST_ID= FND_GLOBAL.CONC_REQUEST_ID
6538 WHERE mai.INSTANCE_ID= v_instance_id;
6539 MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'update so tbl status');
6540 commit;
6541 G_TASK_ATP_RULES :=0;
6542 end if;
6543 end if;
6544
6545 IF lv_task_number>0 THEN -- If it's ok, the vlaue is the task number
6546
6547 lv_task_not_completed := lv_task_not_completed -1;
6548 MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'Tasks remaining :'||lv_task_not_completed);
6549
6550 IF lv_task_not_completed= 0 THEN
6551 var_debug := 4;
6552 EXIT;
6553 END IF;
6554
6555 ELSE
6556
6557 var_debug := 5;
6558 EXIT WHEN lv_task_number= UNRESOVLABLE_ERROR;
6559
6560 DBMS_PIPE.PACK_MESSAGE( -lv_task_number);
6561 -- resend the task to the task queue
6562
6563 MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'Re-sending the task number: '||-lv_task_number||' to the queue');
6564
6565 IF DBMS_PIPE.SEND_MESSAGE( v_pipe_task_que)<>0 THEN
6566 RAISE EX_PIPE_SND;
6567 END IF;
6568
6569 MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'Task number: '||-lv_task_number||' re-sent to the pipe queue');
6570
6571 END IF;
6572
6573 ELSIF lv_pipe_ret_code<> 1 THEN
6574 FND_MESSAGE.SET_NAME('MSC','MSC_CL_RCV_PIPE_ERR');
6575 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
6576
6577 RAISE EX_PIPE_RCV; -- If the error is not time-out error
6578 END IF;
6579
6580 -- ============= Check the execution time ==============
6581
6582 select (SYSDATE- START_TIME) into lv_process_time from dual;
6583
6584 IF lv_process_time > pTIMEOUT/1440.0 THEN Raise EX_PROCESS_TIME_OUT;
6585 END IF;
6586
6587 END LOOP;
6588
6589 MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, '----------------------------------------------------');
6590 FND_MESSAGE.SET_NAME('MSC','MSC_CL_TSK_NOT_COMP');
6591 FND_MESSAGE.SET_TOKEN('LV_TASK_NOT_COMPLETED',lv_task_not_completed);
6592 MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, FND_MESSAGE.GET);
6593
6594 IF (var_debug = 1) THEN
6595 FND_MESSAGE.SET_NAME('MSC','MSC_CL_ERR_PDC_3');
6596 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
6597 ELSIF (var_debug = 2) THEN
6598 FND_MESSAGE.SET_NAME('MSC','MSC_CL_ERR_PDC_1');
6599 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
6600 ELSIF (var_debug = 3) THEN
6601 FND_MESSAGE.SET_NAME('MSC','MSC_CL_ERR_PDC_2');
6602 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
6603 ELSIF (var_debug = 4) THEN
6604 FND_MESSAGE.SET_NAME('MSC','MSC_CL_ERR_PDC_3');
6605 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
6606 ELSIF (var_debug = 5) THEN
6607 FND_MESSAGE.SET_NAME('MSC','MSC_CL_ERR_PDC_4');
6608 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
6609
6610 END IF;
6611
6612 MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, '----------------------------------------------------');
6613
6614
6615 IF lv_task_not_completed > 0 THEN
6616
6617 DBMS_PIPE.PURGE( v_pipe_task_que);
6618
6619 lv_task_number:= -1;
6620
6621 ROLLBACK;
6622
6623 FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_FAIL');
6624 ERRBUF:= FND_MESSAGE.GET;
6625 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, ERRBUF);
6626
6627 RETCODE := MSC_UTIL.G_ERROR;
6628
6629 ELSE
6630
6631 lv_task_number:= 0;
6632
6633 UPDATE MSC_APPS_INSTANCES mai
6634 SET LAST_UPDATE_DATE= v_current_date,
6635 LAST_UPDATED_BY= v_current_user,
6636 REQUEST_ID= FND_GLOBAL.CONC_REQUEST_ID
6637 WHERE mai.INSTANCE_ID= v_instance_id;
6638 commit;
6639 /*
6640 * Commented out for bug 13084110 (Forward port for bug 13023757)
6641 * MSC_CL_DEMAND_ODS_LOAD.LINK_SUPP_SO_DEMAND_11I2 uses this temp
6642 * index. They are dropped after the call to this procedure below.
6643
6644
6645 IF (v_is_partial_refresh) AND
6646 ( (v_coll_prec.mps_flag = MSC_UTIL.SYS_YES )
6647 or (v_coll_prec.wip_flag = MSC_UTIL.SYS_YES )
6648 or (v_coll_prec.po_flag = MSC_UTIL.SYS_YES )
6649 or (v_coll_prec.oh_flag = MSC_UTIL.SYS_YES )
6650 or (v_coll_prec.user_supply_demand_flag = MSC_UTIL.SYS_YES )
6651 or (v_coll_prec.internal_repair_flag = MSC_UTIL.SYS_YES )
6652 or (v_coll_prec.external_repair_flag = MSC_UTIL.SYS_YES )
6653 or (v_coll_prec.payback_demand_supply_flag = MSC_UTIL.SYS_YES )
6654 or (v_coll_prec.eam_forecasts_flag = MSC_UTIL.SYS_YES)
6655 or (v_coll_prec.cmro_forecasts_flag = MSC_UTIL.SYS_YES)) then
6656 IF MSC_CL_SUPPLY_ODS_LOAD.drop_supplies_tmp_ind THEN
6657 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, ' Successfully Dropped the temp Index on Supplies table.' );
6658 ELSE
6659 ROLLBACK;
6660 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, 'Failed in Dropping the temp Index on Supplies table.' );
6661 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, SQLERRM);
6662
6663 RETCODE := MSC_UTIL.G_ERROR;
6664 END IF;
6665 END IF; -- partial_refresh
6666 */
6667 FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_SUCCEED');
6668 ERRBUF:= FND_MESSAGE.GET;
6669 RETCODE := MSC_UTIL.G_SUCCESS ;
6670 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, ERRBUF);
6671
6672 END IF;
6673
6674 lv_debug_retcode := RETCODE;
6675
6676 IF SET_ST_STATUS( ERRBUF, RETCODE, pINSTANCE_ID, MSC_UTIL.G_ST_READY) THEN
6677 COMMIT;
6678 END IF;
6679
6680 IF (lv_debug_retcode = MSC_UTIL.G_ERROR) OR (RETCODE = MSC_UTIL.G_ERROR) THEN
6681 RETCODE := MSC_UTIL.G_ERROR;
6682 END IF;
6683
6684 -- Exit the workers
6685
6686 FOR lc_i IN 1..pTotalWorkerNum LOOP
6687
6688 FND_MESSAGE.SET_NAME('MSC','MSC_CL_SEND_WOR_END');
6689 FND_MESSAGE.SET_TOKEN('LCI',lc_i);
6690 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
6691
6692 DBMS_PIPE.PACK_MESSAGE( lv_task_number);
6693
6694 MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'Sending task number: '||lv_task_number||' to the worker '||lc_i);
6695 IF DBMS_PIPE.SEND_MESSAGE( v_pipe_task_que)<>0 THEN
6696 RAISE EX_PIPE_SND;
6697 END IF;
6698
6699 END LOOP;
6700
6701 lv_worker_committed:= 0;
6702
6703 lv_start_time:= SYSDATE;
6704
6705 -- Monitor the worker exits.
6706 LOOP
6707
6708 lv_pipe_ret_code:= DBMS_PIPE.RECEIVE_MESSAGE( v_pipe_status,
6709 PIPE_TIME_OUT);
6710
6711 IF lv_pipe_ret_code=0 THEN
6712
6713 lv_worker_committed:= lv_worker_committed+1;
6714
6715 FND_MESSAGE.SET_NAME('MSC','MSC_CL_WORKER_COMMIT');
6716 FND_MESSAGE.SET_TOKEN('LV_WORKER_COMMITTED',lv_worker_committed);
6717 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
6718
6719 EXIT WHEN lv_worker_committed= pTotalWorkerNum;
6720
6721 ELSIF lv_pipe_ret_code<> 1 THEN
6722 RAISE EX_PIPE_RCV; -- If the error is not time-out error
6723 END IF;
6724
6725 SELECT (SYSDATE- lv_start_time) INTO lv_process_time FROM dual;
6726 --EXIT WHEN lv_process_time > 10.0/1440.0; -- wait for 10 minutes
6727
6728 IF (lv_process_time > 3.0/1440.0) AND (lv_worker_committed <> pTotalWorkerNum) THEN
6729 EXIT WHEN all_workers_completed(lvs_request_id) = MSC_UTIL.SYS_YES;
6730 END IF;
6731
6732 END LOOP;
6733
6734 IF lv_worker_committed<> pTotalWorkerNum THEN
6735
6736 FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_FAIL_TO_COMMIT');
6737 ERRBUF:= FND_MESSAGE.GET;
6738 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, ERRBUF);
6739 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, SQLERRM);
6740
6741 FND_MESSAGE.SET_NAME('MSC','MSC_CL_CHECK_PDC_LOG');
6742 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, FND_MESSAGE.GET);
6743
6744 RETCODE := MSC_UTIL.G_ERROR;
6745 ELSE
6746 IF lv_task_number= 0 THEN
6747
6748 IF (v_is_cont_refresh) and (
6749 (v_coll_prec.mps_flag = MSC_UTIL.SYS_YES and v_coll_prec.mps_sn_flag = MSC_UTIL.SYS_TGT) or
6750 (v_coll_prec.wip_flag = MSC_UTIL.SYS_YES and v_coll_prec.wip_sn_flag = MSC_UTIL.SYS_TGT) or
6751 (v_coll_prec.po_flag = MSC_UTIL.SYS_YES and v_coll_prec.po_sn_flag = MSC_UTIL.SYS_TGT) or
6752 (v_coll_prec.oh_flag = MSC_UTIL.SYS_YES and v_coll_prec.oh_sn_flag = MSC_UTIL.SYS_TGT) or
6753 (v_coll_prec.supplier_response_flag = MSC_UTIL.SYS_YES) or
6754 (v_coll_prec.user_supply_demand_flag = MSC_UTIL.SYS_YES and v_coll_prec.usup_sn_flag = MSC_UTIL.SYS_TGT) or
6755 (v_coll_prec.eam_forecasts_flag = MSC_UTIL.SYS_YES) or
6756 (v_coll_prec.cmro_forecasts_flag = MSC_UTIL.SYS_YES) or
6757 (v_coll_prec.cmro_closed_wo = MSC_UTIL.SYS_YES) or
6758 (v_coll_prec.osp_supply = MSC_UTIL.SYS_YES)
6759 ) then
6760 IF MSC_CL_SUPPLY_ODS_LOAD.drop_supplies_tmp_ind THEN
6761 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, ' Successfully Dropped the temp Index on Supplies table.' );
6762 ELSE
6763 ROLLBACK;
6764 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, 'Failed in Dropping the temp Index on Supplies table.' );
6765 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, SQLERRM);
6766
6767 RETCODE := MSC_UTIL.G_ERROR;
6768 END IF;
6769 END IF;
6770
6771 IF (v_is_partial_refresh) AND
6772 ( (v_coll_prec.mps_flag = MSC_UTIL.SYS_YES )
6773 or (v_coll_prec.wip_flag = MSC_UTIL.SYS_YES )
6774 or (v_coll_prec.po_flag = MSC_UTIL.SYS_YES )
6775 or (v_coll_prec.oh_flag = MSC_UTIL.SYS_YES )
6776 or (v_coll_prec.supplier_response_flag = MSC_UTIL.SYS_YES)
6777 or (v_coll_prec.user_supply_demand_flag = MSC_UTIL.SYS_YES )
6778 or (v_coll_prec.internal_repair_flag = MSC_UTIL.SYS_YES )
6779 or (v_coll_prec.external_repair_flag = MSC_UTIL.SYS_YES )
6780 or (v_coll_prec.payback_demand_supply_flag = SYS_YES)
6781 or (v_coll_prec.eam_forecasts_flag = MSC_UTIL.SYS_YES)
6782 or (v_coll_prec.cmro_forecasts_flag = MSC_UTIL.SYS_YES)
6783 or (v_coll_prec.cmro_closed_wo = MSC_UTIL.SYS_YES)
6784 or (v_coll_prec.osp_supply = MSC_UTIL.SYS_YES)) then
6785 IF MSC_CL_SUPPLY_ODS_LOAD.drop_supplies_tmp_ind THEN
6786 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, ' Successfully Dropped the temp Index on Supplies table.' );
6787 ELSE
6788 ROLLBACK;
6789 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, 'Failed in Dropping the temp Index on Supplies table.' );
6790 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, SQLERRM);
6791
6792 RETCODE := MSC_UTIL.G_ERROR;
6793 END IF;
6794 END IF; -- partial_refresh
6795
6796 /* ds change start */
6797 IF v_apps_ver >= MSC_UTIL.G_APPS115 THEN
6798 IF MSC_CL_SETUP_ODS_LOAD.LINK_SUPPLY_TOP_LINK_ID THEN
6799 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, 'update of msc_supplies top_transaction_id for eam is successful.....');
6800 ELSE
6801 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, 'Error in update of msc_supplies top_transaction_id......');
6802 RETCODE := MSC_UTIL.G_WARNING;
6803 END IF;
6804 END IF;
6805 /* ds change end */
6806
6807 IF (v_apps_ver >= MSC_UTIL.G_APPS115) AND (v_coll_prec.mds_flag = MSC_UTIL.SYS_YES) THEN
6808 /* call the function to link the Demand_id and Parent_id in MSC_DEMANDS for 11i Source instance */
6809
6810 IF (v_is_partial_refresh) OR --- incremental/partial collections
6811 (v_is_cont_refresh AND v_coll_prec.mds_sn_flag = MSC_UTIL.SYS_TGT) THEN -- in auto collcns if mds is targeted
6812
6813 v_exchange_mode := MSC_UTIL.SYS_YES;
6814
6815 IF MSC_CL_DEMAND_ODS_LOAD.LINK_PARENT_SALES_ORDERS_MDS THEN
6816 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, 'Linking of Sales Order line in MDS to its Parent Sales orders is successful.....');
6817 ELSE
6818 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, 'Error in Linking Sales order line in MDS to its parent Sales order......');
6819 RETCODE := MSC_UTIL.G_WARNING;
6820 END IF;
6821
6822 IF MSC_CL_DEMAND_ODS_LOAD.drop_demands_tmp_ind THEN
6823 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, ' Successfully Dropped the temp Index on Demands table.' );
6824 ELSE
6825 ROLLBACK;
6826 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, 'Failed in Dropping the temp Index on Demands table.' );
6827 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, SQLERRM);
6828
6829 RETCODE := MSC_UTIL.G_ERROR;
6830 END IF; ---- call to MSC_CL_DEMAND_ODS_LOAD.drop_demands_tmp_ind
6831
6832 END IF;
6833 END IF;
6834
6835 IF (v_coll_prec.sales_order_flag = MSC_UTIL.SYS_YES) THEN
6836 IF (v_is_partial_refresh) OR (v_is_cont_refresh and v_coll_prec.so_sn_flag = MSC_UTIL.SYS_TGT) then
6837 IF MSC_CL_DEMAND_ODS_LOAD.drop_sales_orders_tmp_ind THEN
6838 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, ' Successfully Dropped the temp Index on Sales Orders table.' );
6839 ELSE
6840 ROLLBACK;
6841 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, 'Failed in Dropping the temp Index on Sales Orders table.' );
6842 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, SQLERRM);
6843
6844 RETCODE := MSC_UTIL.G_ERROR;
6845 END IF;
6846 END IF;
6847 END IF; -- partial_refresh
6848
6849 IF (v_is_cont_refresh) THEN
6850 v_exchange_mode := MSC_UTIL.SYS_YES;
6851 END IF;
6852
6853 IF v_exchange_mode= MSC_UTIL.SYS_YES THEN
6854
6855 IF alter_temp_table_by_monitor = FALSE THEN
6856 RETCODE:= MSC_UTIL.G_ERROR;
6857 ELSE
6858 NULL;
6859 --log_message ('successfully altered phase 2 tables');
6860 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, 'successfully altered phase 2 tables.' );
6861 END IF;
6862 END IF;
6863
6864 -- Bug 14318618 - link IR/ISO only after indexes on MSC_SUPPLIES_<inst> have been created
6865 -- by alter_temp_table_by_monitor
6866 IF (v_is_partial_refresh AND v_coll_prec.po_flag = MSC_UTIL.SYS_YES AND
6867 v_coll_prec.sales_order_flag =MSC_UTIL.SYS_NO) OR
6868 (v_is_cont_refresh AND (v_coll_prec.po_flag = MSC_UTIL.SYS_YES and
6869 v_coll_prec.po_sn_flag = MSC_UTIL.SYS_TGT) AND
6870 v_coll_prec.sales_order_flag =MSC_UTIL.SYS_NO) THEN
6871 IF ( v_apps_ver >= MSC_UTIL.G_APPS115 ) THEN
6872 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, ' Calling Linking of Sales Order for 11i source ...');
6873 FND_MESSAGE.SET_NAME('MSC', 'MSC_DL_TASK_START_PARTIAL');
6874 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LINK_SUPP_SO_DEMAND_11I2');
6875 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
6876 MSC_CL_DEMAND_ODS_LOAD.LINK_SUPP_SO_DEMAND_11I2;
6877 END IF;
6878 END IF;
6879
6880 IF v_exchange_mode= MSC_UTIL.SYS_YES THEN
6881 MSC_CL_SETUP_ODS_LOAD.GET_COLL_PARAM (pINSTANCE_ID, v_coll_prec);
6882 IF NOT MSC_CL_EXCHANGE_PARTTBL.Exchange_Partition
6883 (v_coll_prec,
6884 v_is_cont_refresh) THEN
6885 /* Only those tables that have partial
6886 // replacement data loaded will be exchanged.
6887 */
6888 RETCODE:= MSC_UTIL.G_ERROR;
6889 END IF;
6890 IF RETCODE <> MSC_UTIL.G_ERROR THEN
6891 IF NOT MSC_CL_EXCHANGE_PARTTBL.Drop_Temp_Tbl THEN
6892 v_warning_flag:=MSC_UTIL.SYS_YES;
6893 END IF;
6894 END IF;
6895
6896 END IF;
6897
6898 IF ( v_coll_prec.item_flag = MSC_UTIL.SYS_YES or v_coll_prec.bom_flag = MSC_UTIL.SYS_YES ) THEN
6899 MSC_CL_ITEM_ODS_LOAD.UPDATE_LEADTIME;
6900 END IF;
6901
6902 IF (v_apps_ver >= MSC_UTIL.G_EAM_CMRO_SUP_VER AND MSC_UTIL.G_CMRO_EAM_INT_ENABLED = 'Y' ) THEN
6903
6904 IF ( v_coll_prec.eam_info_flag = MSC_UTIL.SYS_YES OR v_coll_prec.bom_flag = MSC_UTIL.SYS_YES ) THEN
6905 MSC_CL_EAM_ODS_LOAD.LINK_REBUILD_BOM_ACTIVITY;
6906
6907 END IF;
6908 END IF;
6909
6910 IF (v_apps_ver >= MSC_UTIL.G_EAM_CMRO_SUP_VER AND MSC_UTIL.G_CMRO_EAM_INT_ENABLED = 'Y' ) THEN
6911 IF ( v_coll_prec.eam_info_flag = MSC_UTIL.SYS_YES OR v_coll_prec.wip_flag = MSC_UTIL.SYS_YES ) THEN
6912 MSC_CL_EAM_ODS_LOAD.UPD_PROD_STOCK;
6913 END IF;
6914 END IF;
6915 IF (v_req_ext_po_so_linking) Then
6916 IF ( v_apps_ver >= MSC_UTIL.G_APPS115 ) THEN
6917 BEGIN
6918 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, ' Calling Linking of Sales Order for 11i source ...');
6919 FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
6920 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'MSC_CL_DEMAND_ODS_LOAD.LINK_SUPP_SO_DEMAND_EXT');
6921 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
6922 -- Calling the Linking of external Sales orders for the fix 2353397 --
6923 MSC_CL_DEMAND_ODS_LOAD.LINK_SUPP_SO_DEMAND_EXT;
6924 END;
6925
6926 END IF;
6927 END IF;
6928 --9194726
6929 IF lv_bon_start_end_partial = 3 then
6930 MSC_CL_ROUTING_ODS_LOAD.GET_START_END_OP_PARTIAL ;
6931 END IF;
6932
6933 UPDATE MSC_APPS_INSTANCES
6934 SET so_tbl_status= MSC_UTIL.SYS_YES
6935 WHERE instance_id= v_instance_id;
6936 /* Resource Start Time*/
6937 -- Set The collections Start Time . Get the start time in the out variable
6938 SET_COLLECTIONS_START_TIME(v_instance_id, v_resource_start_time);
6939
6940 IF RETCODE <> MSC_UTIL.G_ERROR THEN
6941 IF v_coll_prec.ibuc_history_flag = MSC_UTIL.SYS_YES THEN
6942 UPDATE MSC_APPS_INSTANCES
6943 SET LAST_IBUC_COLL_DATE = lv_ibuc_coll_start_time
6944 WHERE INSTANCE_ID= pINSTANCE_ID;
6945 END IF;
6946 END IF;
6947 COMMIT;
6948
6949 /*
6950 // Should Loading sourcing History be done
6951 // during partial refreshment if the sourcing history is on in pull and ods.
6952 //
6953 */
6954
6955 IF(v_coll_prec.po_receipts_flag = MSC_UTIL.SYS_YES) THEN
6956 v_sub_str := 'AND ORGANIZATION_ID' || MSC_UTIL.v_in_org_str;
6957 DELETE_MSC_TABLE('MSC_PO_RECEIPTS', v_instance_id,NULL,v_sub_str);
6958 COMMIT;
6959
6960 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, 'Table MSC_PO_RECEIPTS Deleted');
6961
6962 MSC_CL_MISCELLANEOUS.load_po_receipts
6963 ( v_instance_id,
6964 MSC_UTIL.v_in_org_str,
6965 v_last_collection_id,
6966 v_current_date,
6967 v_current_user,
6968 NULL);
6969 COMMIT;
6970 END IF;
6971
6972 IF pPURGE_SH = MSC_UTIL.SYS_YES THEN
6973
6974 SELECT DECODE(nvl(FND_PROFILE.VALUE('MSC_PURGE_ST_CONTROL'),'N'),'Y',1,2)
6975 INTO lv_delete_flag
6976 FROM DUAL;
6977
6978 IF (lv_delete_flag = 2) THEN
6979 DELETE MSC_SOURCING_HISTORY
6980 WHERE SR_INSTANCE_ID= v_instance_id;
6981 ELSE
6982 TRUNCATE_MSC_TABLE('MSC_SOURCING_HISTORY');
6983 END IF;
6984
6985 COMMIT;
6986
6987 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, 'Table MSC_SOURCING_HISTORY Deleted');
6988 END IF;
6989
6990 IF ((pRECALC_SH=MSC_UTIL.SYS_YES) AND (v_coll_prec.source_hist_flag=MSC_UTIL.SYS_YES)) THEN
6991
6992 MSC_CL_MISCELLANEOUS.load_sourcing_history
6993 ( v_instance_id,
6994 v_last_collection_id,
6995 v_current_date,
6996 v_current_user,
6997 NULL);
6998 END IF;
6999
7000 -- SAVEPOINT WORKERS_COMMITTED;
7001
7002 lv_RECALC_NRA := pRECALC_NRA;
7003 IF (v_coll_prec.resource_nra_flag = MSC_UTIL.SYS_YES OR
7004 v_coll_prec.resource_nra_flag = REGEN_AND_COLLECT) THEN--BUG 13724715 (FP of 13907513/12955171)
7005 lv_RECALC_NRA := MSC_UTIL.SYS_YES;
7006 END IF;
7007
7008
7009 -- BUG # 3020614
7010 -- For Partial refresh, if Both the bom_flag and calendar_flag are
7011 -- not set then call the procedure calc_resource_availability in
7012 -- serial mode if pRECALC_NRA is set.
7013 -- Otherwise, the procedure load_calendar_date makes a call to
7014 -- this procedure.
7015
7016
7017 IF (v_is_partial_refresh AND
7018 (v_coll_prec.bom_flag = MSC_UTIL.SYS_NO) AND
7019 (v_coll_prec.calendar_flag = MSC_UTIL.SYS_NO)) THEN
7020
7021
7022 IF v_discrete_flag= MSC_UTIL.SYS_YES AND lv_RECALC_NRA = MSC_UTIL.SYS_YES THEN
7023 /*Resource Start Time*/
7024 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS,'before CALC_RESOURCE_AVAILABILITY ');
7025 lv_ret_res_ava:=MSC_RESOURCE_AVAILABILITY.CALC_RESOURCE_AVAILABILITY(v_resource_start_time,v_coll_prec.org_group_flag,FALSE);
7026
7027
7028 IF lv_ret_res_ava = 2 THEN
7029 FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_CALC_RES_AVAIL_FAIL');
7030 ERRBUF:= FND_MESSAGE.GET;
7031 v_warning_flag:=MSC_UTIL.SYS_YES;
7032 ELSIF lv_ret_res_ava <> 0 THEN
7033 FND_MESSAGE.SET_NAME('MSC', 'MSC_OL_CALC_RES_AVAIL_FAIL');
7034 ERRBUF:= FND_MESSAGE.GET;
7035 RETCODE:= MSC_UTIL.G_ERROR;
7036
7037 -- ROLLBACK WORK TO SAVEPOINT WORKERS_COMMITTED;
7038 END IF;
7039
7040 END IF;
7041 END IF;
7042
7043 END IF; -- lv_task_number= 0
7044
7045 END IF; -- commit fail?
7046
7047 COMMIT;
7048
7049 /* LAUNCH DATA PURGING PROCESS */
7050
7051 -- agmcont
7052 IF (v_cp_enabled= MSC_UTIL.SYS_YES AND RETCODE<>MSC_UTIL.G_ERROR AND
7053 (v_is_cont_refresh = FALSE)) THEN
7054
7055 /* added the code so that the request - Purge Staging tables will be called via function
7056 purge_staging for bug: 2452183 , Planning ODS Load was always completing with warnings
7057 because when the sub-req MSCPDCP completes , it restarts the launch_monitor */
7058
7059 IF PURGE_STAGING(pINSTANCE_ID) THEN
7060 COMMIT;
7061 ELSE
7062 IF RETCODE <> MSC_UTIL.G_ERROR THEN RETCODE := MSC_UTIL.G_WARNING; END IF;
7063 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, SQLERRM);
7064 END IF;
7065
7066 END IF;
7067
7068 -- agmcont
7069 -- call purge procedure directly in case of continuous collections
7070
7071 if (v_is_cont_refresh) AND (RETCODE<>MSC_UTIL.G_ERROR) then
7072
7073 /* call purge staging tables */
7074
7075 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, 'launch purge staging tables');
7076
7077 MSC_CL_COLLECTION.PURGE_STAGING_TABLES( ERRBUF ,
7078 RETCODE,
7079 pINSTANCE_ID,
7080 MSC_UTIL.SYS_YES);
7081
7082
7083 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, 'done purge staging tables');
7084
7085 end if;
7086
7087 COMMIT;
7088
7089
7090 /* ATP SUMMARY CHANGES - LAUNCH CONCURENT PROGRAMS FOR ATP in TARGETED MODE */
7091 /* CHECK TO SEE IF THE PACKAGE EXISTS */
7092 BEGIN
7093 OPEN c_query_package;
7094 FETCH c_query_package INTO lv_atp_package_exists;
7095 CLOSE c_query_package;
7096 /* CHECK TO SEE IF THE ATP PROFILE INV_CTP is set to 5 */
7097 SELECT nvl(fnd_profile.value('INV_CTP'),-10)
7098 INTO lv_inv_ctp
7099 FROM dual;
7100
7101 /* CHECK TO SEE IF THE ATP PROFILE INV_CTP is set to 5 */
7102 SELECT decode(nvl(fnd_profile.value('MSC_ENABLE_ATP_SUMMARY'),'N'),'Y',1,2)
7103 INTO lv_MSC_ENABLE_ATP_SUMMARY
7104 FROM dual;
7105 EXCEPTION
7106 WHEN OTHERS THEN
7107 IF c_query_package%ISOPEN THEN CLOSE c_query_package; END IF;
7108 lv_atp_package_exists := 2;
7109 END;
7110
7111 IF (lv_atp_package_exists = 1 AND lv_inv_ctp = 5 and lv_MSC_ENABLE_ATP_SUMMARY = 1 ) THEN
7112 IF v_is_partial_refresh THEN
7113 BEGIN
7114
7115 IF (v_cp_enabled= MSC_UTIL.SYS_YES ) THEN
7116
7117 MSC_CL_SETUP_ODS_LOAD.GET_COLL_PARAM (pINSTANCE_ID); -- This will initialze the record v_coll_prec
7118 IF ( (v_coll_prec.mps_flag = MSC_UTIL.SYS_YES) or
7119 (v_coll_prec.po_flag = MSC_UTIL.SYS_YES) or
7120 (v_coll_prec.oh_flag = MSC_UTIL.SYS_YES) or
7121 (v_coll_prec.wip_flag = MSC_UTIL.SYS_YES) or
7122 (v_coll_prec.user_supply_demand_flag = MSC_UTIL.SYS_YES) or
7123 (v_coll_prec.forecast_flag = MSC_UTIL.SYS_YES) or
7124 (v_coll_prec.mds_flag = MSC_UTIL.SYS_YES) ) THEN
7125
7126 lv_refresh_sd := MSC_UTIL.SYS_YES;
7127 ELSE
7128 lv_refresh_sd := MSC_UTIL.SYS_NO;
7129
7130 END IF;
7131
7132 IF (v_coll_prec.sales_order_flag = MSC_UTIL.SYS_YES) THEN
7133 lv_refresh_so := MSC_UTIL.SYS_YES;
7134 ELSE
7135 lv_refresh_so := MSC_UTIL.SYS_NO;
7136 END IF;
7137
7138 lv_atp_request_id := FND_REQUEST.SUBMIT_REQUEST(
7139 'MSC',
7140 'MSCCLCNC',
7141 NULL, -- description
7142 NULL, -- start date
7143 FALSE, -- sub request,
7144 pINSTANCE_ID, -- Instance Id
7145 3, -- Refresh type Targeted
7146 lv_refresh_so, -- Refresh SO Incremental
7147 lv_refresh_sd); -- Refresh Supply/Demand
7148 END IF; -- cp enabled flag
7149
7150 COMMIT;
7151 EXCEPTION
7152 WHEN OTHERS THEN
7153 ERRBUF:=SQLERRM||' Request: '||lv_atp_request_id||' Error in Call To program MSCCLCNC ';
7154 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, ERRBUF);
7155 END;
7156
7157 ELSIF v_is_incremental_refresh THEN -- Incremental refresh No, Sales Orders refresh No
7158
7159 /* ATP SUMMARY CHANGES CALL THE PROGRAMS MSCCLCNC For Incremental refresh collections */
7160
7161 BEGIN
7162 IF v_cp_enabled= MSC_UTIL.SYS_YES THEN
7163 lv_atp_request_id := FND_REQUEST.SUBMIT_REQUEST(
7164 'MSC',
7165 'MSCCLCNC',
7166 NULL, -- description
7167 NULL, -- start date
7168 FALSE, -- sub request,
7169 pINSTANCE_ID, -- Instance Id
7170 MSC_UTIL.SYS_NO, -- Refresh type Incremental
7171 MSC_UTIL.SYS_NO, -- Refresh SO Incremental
7172 MSC_UTIL.SYS_NO); -- Refresh Supply/Demand
7173 END IF; -- cp enabled flag
7174 COMMIT;
7175 EXCEPTION
7176 WHEN OTHERS THEN
7177 ERRBUF:=SQLERRM||' Request: '||lv_atp_request_id||' Error in Call To program MSCCLCNC ';
7178 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, ERRBUF);
7179 END;
7180
7181 ELSIF v_is_cont_refresh THEN
7182 BEGIN
7183 IF (v_cp_enabled= MSC_UTIL.SYS_YES ) THEN
7184
7185 MSC_CL_SETUP_ODS_LOAD.GET_COLL_PARAM (pINSTANCE_ID); -- This will initialze the record v_coll_prec
7186 IF ( (v_coll_prec.mps_flag = MSC_UTIL.SYS_YES and v_coll_prec.mps_sn_flag=MSC_UTIL.SYS_TGT ) or
7187 (v_coll_prec.po_flag = MSC_UTIL.SYS_YES and v_coll_prec.po_sn_flag=MSC_UTIL.SYS_TGT) or
7188 (v_coll_prec.oh_flag = MSC_UTIL.SYS_YES and v_coll_prec.oh_sn_flag=MSC_UTIL.SYS_TGT) or
7189 (v_coll_prec.wip_flag = MSC_UTIL.SYS_YES and v_coll_prec.wip_sn_flag=MSC_UTIL.SYS_TGT) or
7190 (v_coll_prec.user_supply_demand_flag = MSC_UTIL.SYS_YES and v_coll_prec.udmd_sn_flag=MSC_UTIL.SYS_TGT) or
7191 (v_coll_prec.forecast_flag = MSC_UTIL.SYS_YES and v_coll_prec.fcst_sn_flag=MSC_UTIL.SYS_TGT) or
7192 (v_coll_prec.mds_flag = MSC_UTIL.SYS_YES and v_coll_prec.mds_sn_flag=MSC_UTIL.SYS_TGT) ) THEN
7193
7194 lv_refresh_sd := MSC_UTIL.SYS_YES;
7195 ELSE
7196 lv_refresh_sd := MSC_UTIL.SYS_NO;
7197
7198 END IF;
7199
7200 IF (v_coll_prec.sales_order_flag = MSC_UTIL.SYS_YES and v_coll_prec.so_sn_flag=MSC_UTIL.SYS_TGT ) THEN
7201 lv_refresh_so := MSC_UTIL.SYS_YES;
7202 ELSE
7203 lv_refresh_so := MSC_UTIL.SYS_NO;
7204 END IF;
7205
7206 IF (lv_refresh_sd = MSC_UTIL.SYS_YES OR lv_refresh_so = MSC_UTIL.SYS_YES ) THEN
7207
7208 lv_atp_request_id := FND_REQUEST.SUBMIT_REQUEST(
7209 'MSC',
7210 'MSCCLCNC',
7211 NULL, -- description
7212 NULL, -- start date
7213 FALSE, -- sub request,
7214 pINSTANCE_ID, -- Instance Id
7215 3, -- Refresh type Targeted
7216 lv_refresh_so, -- Refresh SO Incremental
7217 lv_refresh_sd); -- Refresh Supply/Demand
7218
7219 ELSE
7220
7221 lv_atp_request_id := FND_REQUEST.SUBMIT_REQUEST(
7222 'MSC',
7223 'MSCCLCNC',
7224 NULL, -- description
7225 NULL, -- start date
7226 FALSE, -- sub request,
7227 pINSTANCE_ID, -- Instance Id
7228 2, -- Refresh type Incremental
7229 lv_refresh_so, -- Refresh SO Incremental
7230 lv_refresh_sd); -- Refresh Supply/Demand
7231 END IF;
7232
7233
7234 END IF; -- cp enabled flag
7235
7236 COMMIT;
7237 EXCEPTION
7238 WHEN OTHERS THEN
7239 ERRBUF:=SQLERRM||' Request: '||lv_atp_request_id||' Error in Call To program MSCCLCNC ';
7240 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, ERRBUF);
7241 END;
7242 END IF; -- Partial refresh Condition
7243 END IF; -- ATP Package exists or not and the profile options are set or not
7244
7245
7246 /* ATP SUMMARY CHANGES - END - LAUNCH CONCURENT PROGRAMS FOR ATP in TARGETED MODE */
7247
7248
7249 COMMIT;
7250 /* SCE Change Starts */
7251 /* If MSC:Configuration profile is set to SCE or APS+SCE then we need to publish
7252 ODS data to collaboration area i.e. msc_sup_dem_entries.
7253 The SCE program will push following order types.
7254 - Purchase Order (Order_Type = 1)
7255 - PO in receiving (Order Type = 8)
7256 - Requisition (Order_Type = 2)
7257 - Intransit Shipment (Order_Type) = 11
7258 */
7259
7260 BEGIN
7261 IF MSC_UTIL.G_MSC_CONFIGURATION = MSC_UTIL.G_CONF_APS_SCE OR
7262 MSC_UTIL.G_MSC_CONFIGURATION = MSC_UTIL.G_CONF_SCE THEN
7263
7264 -- agmcont
7265 IF (v_cp_enabled= MSC_UTIL.SYS_YES) THEN
7266
7267 lv_sce_pub_req_id := FND_REQUEST.SUBMIT_REQUEST(
7268 'MSC',
7269 'MSCXPUBO',
7270 NULL, -- description
7271 NULL, -- start date
7272 FALSE, -- sub request,
7273 v_instance_id,
7274 v_current_user,
7275 v_coll_prec.po_flag,
7276 v_coll_prec.oh_flag,
7277 v_coll_prec.sales_order_flag,
7278 v_coll_prec.app_supp_cap_flag,
7279 /* CP-ACK starts */
7280 v_coll_prec.supplier_response_flag,
7281 /* CP-ACK ends */
7282 v_coll_prec.po_sn_flag,
7283 v_coll_prec.oh_sn_flag,
7284 v_coll_prec.so_sn_flag,
7285 /* CP-AUTO */
7286 v_coll_prec.suprep_sn_flag
7287 );
7288
7289
7290 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, 'Launched Collaboration ODS Load. Request Id = '||lv_sce_pub_req_id);
7291
7292 END IF;
7293
7294 END IF;
7295 EXCEPTION WHEN OTHERS THEN
7296 ERRBUF:=SQLERRM||' Request: '||lv_sce_pub_req_id||' Error in Call To program MSCXPUBO ';
7297 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, ERRBUF);
7298 END;
7299
7300 COMMIT;
7301
7302 /* SCE Change Ends */
7303
7304 -- DELETE SESSION INFO FROM MSC_COLL_PARAMETERS
7305 -- by calling the procedure FINAL
7306
7307 -----Code changes for APCC refresh-----------
7308 BEGIN
7309
7310
7311 IF (pAPCC_refresh = MSC_UTIL.SYS_YES) THEN
7312 IF (v_is_partial_refresh) THEN
7313 l_req_id := fnd_request.submit_request(
7314 'MSC',
7315 'MSCHUBO',
7316 NULL,
7317 NULL,
7318 FALSE,
7319 pINSTANCE_ID,
7320 2,
7321 NULL);
7322
7323 ELSIF (v_is_complete_refresh) THEN
7324 l_req_id := fnd_request.submit_request(
7325 'MSC',
7326 'MSCHUBO',
7327 NULL,
7328 NULL,
7329 FALSE,
7330 pINSTANCE_ID,
7331 1,
7332 NULL);
7333 END IF;
7334
7335 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, 'LAUNCH_MON_PARTIAL Launched APCC refresh data collections CP. Request Id = '||l_req_id);
7336 END IF;
7337 EXCEPTION WHEN OTHERS THEN
7338 ERRBUF:=SQLERRM||' Request: '||l_req_id||' Error in Call To program MSCHUBO ';
7339 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, ERRBUF);
7340 END;
7341
7342 COMMIT;
7343 -----end of changes for APCC refresh----------
7344
7345 FINAL;
7346
7347 IF RETCODE= MSC_UTIL.G_ERROR THEN
7348 IF SET_ST_STATUS( ERRBUF, RETCODE, pINSTANCE_ID, MSC_UTIL.G_ST_READY) THEN
7349 COMMIT;
7350 END IF;
7351 RETCODE:= MSC_UTIL.G_ERROR ;
7352 --Rollback swap partitions
7353 IF NOT MSC_CL_EXCHANGE_PARTTBL.UNDO_STG_ODS_SWAP THEN
7354 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR,' Exchange partition failed ');
7355 END IF;
7356
7357 RETURN;
7358 END IF;
7359
7360 IF v_warning_flag=MSC_UTIL.SYS_YES THEN
7361 RETCODE:= MSC_UTIL.G_WARNING;
7362 ELSE
7363 RETCODE := MSC_UTIL.G_SUCCESS ;
7364 END IF;
7365
7366 EXCEPTION
7367
7368 WHEN EX_PIPE_RCV THEN
7369
7370 ROLLBACK;
7371
7372 IF lv_check_point= 2 THEN
7373 IF SET_ST_STATUS( ERRBUF, RETCODE, pINSTANCE_ID, MSC_UTIL.G_ST_READY) THEN
7374 NULL;
7375 END IF;
7376 END IF;
7377
7378 --Rollback swap partitions
7379 IF NOT MSC_CL_EXCHANGE_PARTTBL.UNDO_STG_ODS_SWAP THEN
7380 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR,' Exchange partition failed ');
7381 END IF;
7382
7383 -- DELETE SESSION INFO FROM MSC_COLL_PARAMETERS
7384 -- by calling the procedure FINAL
7385
7386 FINAL;
7387 RETCODE := MSC_UTIL.G_ERROR;
7388
7389 COMMIT;
7390
7391 WHEN EX_PIPE_SND THEN
7392
7393 ROLLBACK;
7394
7395 IF lv_check_point= 2 THEN
7396 IF SET_ST_STATUS( ERRBUF, RETCODE, pINSTANCE_ID, MSC_UTIL.G_ST_READY) THEN
7397 NULL;
7398 END IF;
7399 END IF;
7400
7401 FND_MESSAGE.SET_NAME('MSC', 'MSC_MSG_SEND_FAIL');
7402 FND_MESSAGE.SET_TOKEN('PIPE', v_pipe_wm);
7403 ERRBUF:= FND_MESSAGE.GET;
7404
7405 --Rollback swap partitions
7406 IF NOT MSC_CL_EXCHANGE_PARTTBL.UNDO_STG_ODS_SWAP THEN
7407 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR,' Exchange partition failed ');
7408 END IF;
7409
7410 -- DELETE SESSION INFO FROM MSC_COLL_PARAMETERS
7411 -- by calling the procedure FINAL
7412
7413 FINAL;
7414 RETCODE := MSC_UTIL.G_ERROR;
7415
7416 COMMIT;
7417
7418 WHEN EX_PROCESS_TIME_OUT THEN
7419
7420 ROLLBACK;
7421
7422 IF lv_check_point= 2 THEN
7423 IF SET_ST_STATUS( ERRBUF, RETCODE, pINSTANCE_ID, MSC_UTIL.G_ST_READY) THEN
7424 NULL;
7425 END IF;
7426 END IF;
7427
7428 FND_MESSAGE.SET_NAME('MSC', 'MSC_TIMEOUT');
7429 ERRBUF:= FND_MESSAGE.GET;
7430
7431 --Rollback swap partitions
7432 IF NOT MSC_CL_EXCHANGE_PARTTBL.UNDO_STG_ODS_SWAP THEN
7433 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR,' Exchange partition failed ');
7434 END IF;
7435
7436 -- DELETE SESSION INFO FROM MSC_COLL_PARAMETERS
7437 -- by calling the procedure FINAL
7438
7439 FINAL;
7440 RETCODE := MSC_UTIL.G_ERROR;
7441
7442 COMMIT;
7443
7444 WHEN others THEN
7445
7446 ROLLBACK;
7447
7448 IF lv_check_point= 2 THEN
7449 IF SET_ST_STATUS( ERRBUF, RETCODE, pINSTANCE_ID, MSC_UTIL.G_ST_READY) THEN
7450 NULL;
7451 END IF;
7452 END IF;
7453
7454 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, SQLERRM);
7455
7456 --Rollback swap partitions
7457 IF NOT MSC_CL_EXCHANGE_PARTTBL.UNDO_STG_ODS_SWAP THEN
7458 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR,' Exchange partition failed ');
7459 END IF;
7460
7461 -- DELETE SESSION INFO FROM MSC_COLL_PARAMETERS
7462 -- by calling the procedure FINAL
7463
7464 FINAL;
7465 ERRBUF := SQLERRM;
7466 RETCODE := MSC_UTIL.G_ERROR;
7467
7468 COMMIT;
7469
7470 END LAUNCH_MON_PARTIAL;
7471
7472 -- agmcont:
7473
7474
7475
7476
7477
7478 /*************** PREPLACE CHANGE END *****************/
7479
7480 /* added this procedure for the conc program - Create Instance-Org Supplier Association
7481 This conc program updates the Msc_trading_partners table with the Modeleed Supplier info */
7482
7483 PROCEDURE ENTER_MODELLED_INFO( ERRBUF OUT NOCOPY VARCHAR2,
7484 RETCODE OUT NOCOPY NUMBER,
7485 pINSTANCE_ID IN NUMBER,
7486 pDEST_PARTNER_ORG_ID IN NUMBER,
7487 pSUPPLIER_ID IN NUMBER,
7488 pSUPPLIER_SITE_ID IN NUMBER,
7489 pACCEPT_DEMANDS_FROM_UNMET_PO IN NUMBER)
7490 IS
7491 BEGIN
7492
7493 IF ( (pSUPPLIER_ID IS NULL) AND (pSUPPLIER_SITE_ID IS NULL) ) THEN
7494
7495 UPDATE msc_trading_partners
7496 SET MODELED_SUPPLIER_ID = null,
7497 MODELED_SUPPLIER_SITE_ID = null,
7498 ORG_SUPPLIER_MAPPED = 'N',
7499 ACCEPT_DEMANDS_FROM_UNMET_PO = null
7500 WHERE sr_instance_id = pINSTANCE_ID
7501 AND PARTNER_ID = pDEST_PARTNER_ORG_ID
7502 AND PARTNER_TYPE = 3;
7503
7504 COMMIT;
7505
7506 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, '================================================');
7507 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, 'Removed the Modeled Information for Partner Id : '||pDEST_PARTNER_ORG_ID );
7508 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, '================================================');
7509
7510 RETCODE := MSC_UTIL.G_SUCCESS ;
7511
7512 ELSE
7513
7514 UPDATE msc_trading_partners
7515 SET MODELED_SUPPLIER_ID = pSUPPLIER_ID,
7516 MODELED_SUPPLIER_SITE_ID = pSUPPLIER_SITE_ID,
7517 ORG_SUPPLIER_MAPPED = 'Y',
7518 ACCEPT_DEMANDS_FROM_UNMET_PO = pACCEPT_DEMANDS_FROM_UNMET_PO
7519 WHERE sr_instance_id = pINSTANCE_ID
7520 AND PARTNER_ID = pDEST_PARTNER_ORG_ID
7521 AND PARTNER_TYPE = 3;
7522
7523 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, '================================================');
7524 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, 'Updated the Partner Id : '||pDEST_PARTNER_ORG_ID );
7525 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, 'Modelled Supplier as : '||pSUPPLIER_ID);
7526 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, 'Modelled Supplier Site as : '||pSUPPLIER_SITE_ID);
7527 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, 'Accept Demands From Unmet PO as : '||pACCEPT_DEMANDS_FROM_UNMET_PO);
7528 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, '================================================');
7529
7530 COMMIT;
7531
7532 RETCODE := MSC_UTIL.G_SUCCESS ;
7533
7534 END IF;
7535
7536 EXCEPTION
7537 WHEN OTHERS THEN
7538 ROLLBACK;
7539 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, 'An error has occurred.');
7540 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, SQLERRM);
7541 RETCODE := MSC_UTIL.G_ERROR;
7542
7543 END ENTER_MODELLED_INFO;
7544
7545 PROCEDURE COMPUTE_RES_AVAIL (ERRBUF OUT NOCOPY VARCHAR2,
7546 RETCODE OUT NOCOPY NUMBER,
7547 pINSTANCE_ID IN NUMBER,
7548 pSTART_DATE IN VARCHAR2)
7549 IS
7550 BEGIN
7551 MSC_RESOURCE_AVAILABILITY.COMPUTE_RES_AVAIL( ERRBUF ,
7552 RETCODE ,
7553 pINSTANCE_ID,
7554 pSTART_DATE ) ;
7555
7556
7557 END COMPUTE_RES_AVAIL;
7558 /* After Splitting GENERATE_ITEM_KEYS is placed in MSC_CL_ITEM_ODS_LOAD package . This is a wrapper for the same.*/
7559
7560 PROCEDURE GENERATE_ITEM_KEYS (
7561 ERRBUF OUT NOCOPY VARCHAR2,
7562 RETCODE OUT NOCOPY NUMBER,
7563 pINSTANCE_ID IN NUMBER) IS
7564 BEGIN
7565
7566 MSC_CL_ITEM_ODS_LOAD.GENERATE_ITEM_KEYS (ERRBUF,RETCODE,pINSTANCE_ID);
7567
7568 END GENERATE_ITEM_KEYS;
7569
7570 PROCEDURE GENERATE_TRADING_PARTNER_KEYS (ERRBUF OUT NOCOPY VARCHAR2,
7571 RETCODE OUT NOCOPY NUMBER,
7572 pINSTANCE_ID IN NUMBER) IS
7573 BEGIN
7574
7575 MSC_CL_SETUP_ODS_LOAD.GENERATE_TRADING_PARTNER_KEYS (ERRBUF,RETCODE,pINSTANCE_ID);
7576
7577 END GENERATE_TRADING_PARTNER_KEYS;
7578
7579
7580 PROCEDURE LAUNCH_MONITOR_DET_SCH( ERRBUF OUT NOCOPY VARCHAR2,
7581 RETCODE OUT NOCOPY NUMBER,
7582 pINSTANCE_ID IN NUMBER,
7583 pTIMEOUT IN NUMBER,
7584 pTotalWorkerNum IN NUMBER,
7585 pRECALC_NRA IN NUMBER,
7586 pAPCC_refresh IN NUMBER DEFAULT MSC_UTIL.SYS_NO)
7587
7588 IS
7589 lERRBUF VARCHAR2(240) ;
7590 lRETCODE NUMBER;
7591 begin
7592 v_DSMode := MSC_UTIL.SYS_YES;
7593 p_TIMEOUT := pTIMEOUT;
7594 MSC_UTIL.LOG_MSG(MSC_UTIL.G_D_DEBUG_1, 'calling launch monitor. recalc_nra= '||pRECALC_NRA);
7595
7596 LAUNCH_MONITOR(lERRBUF,
7597 lRETCODE,
7598 pINSTANCE_ID,
7599 pTIMEOUT,
7600 pTotalWorkerNum,
7601 pRECALC_NRA, --lv_RECALC_NRA,
7602 MSC_UTIL.SYS_NO, --lv_RECALC_SH,
7603 MSC_UTIL.SYS_NO, -------lv_PURGE_SH);
7604 MSC_UTIL.SYS_NO);
7605 ERRBUF := lERRBUF;
7606 RETCODE := lRETCODE ;
7607 END LAUNCH_MONITOR_DET_SCH;
7608 /* procedure CLEAN_LIAB_AGREEMENT has been moved to package MSC_CL_SETUP_ODS_LOAD
7609 through bug5952569 */
7610
7611 PROCEDURE alter_temp_table (ERRBUF OUT NOCOPY VARCHAR2,
7612 RETCODE OUT NOCOPY NUMBER,
7613 p_part_table IN VARCHAR2,
7614 p_instance_code IN VARCHAR2,
7615 p_severity_level IN NUMBER
7616 )
7617 IS
7618 lv_crt_ind_status NUMBER;
7619 INDEX_CREATION_ERROR EXCEPTION;
7620 lv_errbuf VARCHAR2(240);
7621 lv_retcode NUMBER := MSC_UTIL.G_SUCCESS ;
7622 lv_instance_id NUMBER;
7623 lv_is_plan NUMBER := MSC_UTIL.SYS_NO;
7624 lv_temp_tbl_name VARCHAR2(32);
7625
7626 EXCHG_PRT_ERROR EXCEPTION;
7627
7628 BEGIN
7629
7630 FND_MESSAGE.SET_NAME('MSC', 'MSC_DP_TASK_START');
7631 FND_MESSAGE.SET_TOKEN('PROCEDURE', 'alter_temp_table');
7632 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, FND_MESSAGE.GET);
7633
7634 SELECT instance_id
7635 INTO lv_instance_id
7636 FROM msc_apps_instances
7637 WHERE upper(instance_code) = p_instance_code;
7638
7639 IF MSC_CL_EXCHANGE_PARTTBL.Initialize( lv_instance_id,
7640 p_instance_code,
7641 FALSE) THEN
7642 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS,'MSC_CL_EXCHANGE_PARTTBL.Initialize successful');
7643 ELSE
7644 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR,'MSC_CL_EXCHANGE_PARTTBL.Initialize - failed');
7645 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, sqlerrm);
7646 RAISE EXCHG_PRT_ERROR;
7647 END IF;
7648
7649 lv_temp_tbl_name := SUBSTR(p_part_table, 5, LENGTH(p_part_table)) || '_' || p_instance_code;
7650
7651 msc_analyse_tables_pk.analyse_table(lv_temp_tbl_name);
7652
7653 lv_crt_ind_status := MSC_CL_EXCHANGE_PARTTBL.create_temp_table_index
7654 ('UNIQUE',
7655 p_part_table,
7656 lv_temp_tbl_name,
7657 p_instance_code,
7658 lv_instance_id,
7659 lv_is_plan,
7660 p_severity_level
7661 );
7662
7663 IF lv_crt_ind_status = MSC_UTIL.G_ERROR THEN
7664 FND_MESSAGE.SET_NAME('MSC', 'MSC_CRT_IND_STATUS');
7665 FND_MESSAGE.SET_TOKEN('UNIQUENESS', 'UNIQUE');
7666 FND_MESSAGE.SET_TOKEN('TABLE_NAME', lv_temp_tbl_name);
7667 FND_MESSAGE.SET_TOKEN('STATUS', 'ERROR');
7668
7669 lv_errbuf := FND_MESSAGE.GET;
7670 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, lv_errbuf);
7671 RAISE INDEX_CREATION_ERROR;
7672 ELSE
7673 IF lv_crt_ind_status = MSC_UTIL.G_WARNING THEN
7674 FND_MESSAGE.SET_NAME('MSC', 'MSC_CRT_IND_STATUS');
7675 FND_MESSAGE.SET_TOKEN('UNIQUENESS', 'UNIQUE');
7676 FND_MESSAGE.SET_TOKEN('TABLE_NAME', lv_temp_tbl_name);
7677 FND_MESSAGE.SET_TOKEN('STATUS', 'WARNING');
7678
7679 lv_errbuf := FND_MESSAGE.GET;
7680 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, lv_errbuf);
7681 lv_retcode := MSC_UTIL.G_WARNING;
7682 ELSE
7683 FND_MESSAGE.SET_NAME('MSC', 'MSC_CRT_IND_STATUS');
7684 FND_MESSAGE.SET_TOKEN('UNIQUENESS', 'UNIQUE');
7685 FND_MESSAGE.SET_TOKEN('TABLE_NAME', lv_temp_tbl_name);
7686 FND_MESSAGE.SET_TOKEN('STATUS', 'SUCCESS');
7687
7688 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS,FND_MESSAGE.GET);
7689 END IF;
7690
7691 lv_crt_ind_status := MSC_CL_EXCHANGE_PARTTBL.create_temp_table_index
7692 ('NONUNIQUE',
7693 p_part_table,
7694 lv_temp_tbl_name,
7695 p_instance_code,
7696 lv_instance_id,
7697 lv_is_plan,
7698 p_severity_level
7699 );
7700 IF lv_crt_ind_status = MSC_UTIL.G_WARNING THEN
7701 FND_MESSAGE.SET_NAME('MSC', 'MSC_CRT_IND_STATUS');
7702 FND_MESSAGE.SET_TOKEN('UNIQUENESS', 'NONUNIQUE');
7703 FND_MESSAGE.SET_TOKEN('TABLE_NAME', lv_temp_tbl_name);
7704 FND_MESSAGE.SET_TOKEN('STATUS', 'WARNING');
7705
7706 lv_errbuf := FND_MESSAGE.GET;
7707 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS, lv_errbuf);
7708 lv_retcode := MSC_UTIL.G_WARNING;
7709 ELSIF lv_crt_ind_status = MSC_UTIL.G_ERROR THEN
7710 FND_MESSAGE.SET_NAME('MSC', 'MSC_CRT_IND_STATUS');
7711 FND_MESSAGE.SET_TOKEN('UNIQUENESS', 'NONUNIQUE');
7712 FND_MESSAGE.SET_TOKEN('TABLE_NAME', lv_temp_tbl_name);
7713 FND_MESSAGE.SET_TOKEN('STATUS', 'ERROR');
7714
7715 lv_errbuf := FND_MESSAGE.GET;
7716 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, lv_errbuf);
7717 RAISE INDEX_CREATION_ERROR;
7718 ELSE
7719 FND_MESSAGE.SET_NAME('MSC', 'MSC_CRT_IND_STATUS');
7720 FND_MESSAGE.SET_TOKEN('UNIQUENESS', 'NONUNIQUE');
7721 FND_MESSAGE.SET_TOKEN('TABLE_NAME', lv_temp_tbl_name);
7722 FND_MESSAGE.SET_TOKEN('STATUS', 'SUCCESS');
7723
7724 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS,FND_MESSAGE.GET);
7725 END IF;
7726 END IF;
7727
7728 FND_MESSAGE.SET_NAME('MSC', 'MSC_CRT_IND_STATUS');
7729 FND_MESSAGE.SET_TOKEN('UNIQUENESS', 'Unique and Nonunique');
7730 FND_MESSAGE.SET_TOKEN('TABLE_NAME', lv_temp_tbl_name);
7731 FND_MESSAGE.SET_TOKEN('STATUS', 'SUCCESS');
7732
7733 lv_errbuf := FND_MESSAGE.GET;
7734
7735 ERRBUF := lv_errbuf;
7736 RETCODE := lv_retcode;
7737
7738 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_STATUS,'End alter_temp_table');
7739
7740 EXCEPTION
7741 WHEN INDEX_CREATION_ERROR THEN
7742 RAISE;
7743 WHEN OTHERS THEN
7744 ERRBUF := sqlerrm;
7745 RETCODE := MSC_UTIL.G_ERROR;
7746 MSC_UTIL.LOG_MSG(MSC_UTIL.G_LVL_FATAL_ERR, sqlerrm);
7747
7748 RAISE;
7749 END alter_temp_table;
7750
7751 -- ============== KEY TRANSFORMATION FOR ITEMS, CATEGORY SETS =================
7752
7753
7754
7755 -- ============== KEY TRANSFORMATION FOR TRADING PARTNERS =================
7756
7757 -- need to be decided (rama)
7758 FUNCTION LAUNCH_MONITOR_CONT(
7759 ERRBUF OUT NOCOPY VARCHAR2,
7760 RETCODE OUT NOCOPY NUMBER,
7761 pINSTANCE_ID IN NUMBER,
7762 pTIMEOUT IN NUMBER,-- minutes
7763 pTotalWorkerNum IN NUMBER,
7764 pDSMode IN NUMBER default MSC_UTIL.SYS_NO,
7765 pAPCC_refresh IN NUMBER DEFAULT MSC_UTIL.SYS_NO)
7766
7767 RETURN boolean is
7768
7769 lv_RECALC_NRA NUMBER :=2;
7770 lv_RECALC_SH NUMBER :=2;
7771 lv_PURGE_SH NUMBER :=2;
7772
7773 begin
7774 v_DSMode := pDSMode;
7775 p_TIMEOUT := pTIMEOUT;
7776 LAUNCH_MONITOR(ERRBUF,
7777 RETCODE,
7778 pINSTANCE_ID,
7779 pTIMEOUT,
7780 pTotalWorkerNum,
7781 MSC_UTIL.SYS_NO, --lv_RECALC_NRA,
7782 MSC_UTIL.SYS_NO, --lv_RECALC_SH,
7783 MSC_UTIL.SYS_NO, -------lv_PURGE_SH);
7784 MSC_UTIL.SYS_NO);
7785
7786 IF RETCODE <> MSC_UTIL.G_ERROR THEN
7787 RETURN TRUE;
7788 ELSE
7789 RETURN FALSE;
7790 END IF;
7791
7792 END LAUNCH_MONITOR_CONT;
7793 --
7794
7795
7796 END MSC_CL_COLLECTION;