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