APPS.OKC_AQ_PVT dependencies on OKC_DEBUG

Line 42: okc_debug.Set_Indentation(l_proc);

38: --
39:
40: BEGIN
41: IF (l_debug = 'Y') THEN
42: okc_debug.Set_Indentation(l_proc);
43: okc_debug.Log('10: Entering ',2);
44: END IF;
45:
46: OPEN acn_cur;

Line 43: okc_debug.Log('10: Entering ',2);

39:
40: BEGIN
41: IF (l_debug = 'Y') THEN
42: okc_debug.Set_Indentation(l_proc);
43: okc_debug.Log('10: Entering ',2);
44: END IF;
45:
46: OPEN acn_cur;
47: FETCH acn_cur INTO acn_rec;

Line 50: okc_debug.Log('1000: Leaving ',2);

46: OPEN acn_cur;
47: FETCH acn_cur INTO acn_rec;
48: IF acn_cur%NOTFOUND THEN
49: IF (l_debug = 'Y') THEN
50: okc_debug.Log('1000: Leaving ',2);
51: okc_debug.Reset_Indentation;
52: END IF;
53: RETURN('Not Available');
54: ELSE

Line 51: okc_debug.Reset_Indentation;

47: FETCH acn_cur INTO acn_rec;
48: IF acn_cur%NOTFOUND THEN
49: IF (l_debug = 'Y') THEN
50: okc_debug.Log('1000: Leaving ',2);
51: okc_debug.Reset_Indentation;
52: END IF;
53: RETURN('Not Available');
54: ELSE
55: v_acn_type := acn_rec.acn_type;

Line 58: okc_debug.Log('2000: Leaving ',2);

54: ELSE
55: v_acn_type := acn_rec.acn_type;
56:
57: IF (l_debug = 'Y') THEN
58: okc_debug.Log('2000: Leaving ',2);
59: okc_debug.Reset_Indentation;
60: END IF;
61:
62: RETURN(v_acn_type);

Line 59: okc_debug.Reset_Indentation;

55: v_acn_type := acn_rec.acn_type;
56:
57: IF (l_debug = 'Y') THEN
58: okc_debug.Log('2000: Leaving ',2);
59: okc_debug.Reset_Indentation;
60: END IF;
61:
62: RETURN(v_acn_type);
63: END IF;

Line 69: okc_debug.Log('3000: Leaving ',2);

65:
66: EXCEPTION
67: WHEN others THEN
68: IF (l_debug = 'Y') THEN
69: okc_debug.Log('3000: Leaving ',2);
70: okc_debug.Reset_Indentation;
71: END IF;
72: RETURN('Not Available');
73: END get_acn_type;

Line 70: okc_debug.Reset_Indentation;

66: EXCEPTION
67: WHEN others THEN
68: IF (l_debug = 'Y') THEN
69: okc_debug.Log('3000: Leaving ',2);
70: okc_debug.Reset_Indentation;
71: END IF;
72: RETURN('Not Available');
73: END get_acn_type;
74:

Line 93: okc_debug.Set_Indentation(l_proc);

89: --
90:
91: BEGIN
92: IF (l_debug = 'Y') THEN
93: okc_debug.Set_Indentation(l_proc);
94: okc_debug.Log('10: Entering ',2);
95: END IF;
96:
97:

Line 94: okc_debug.Log('10: Entering ',2);

90:
91: BEGIN
92: IF (l_debug = 'Y') THEN
93: okc_debug.Set_Indentation(l_proc);
94: okc_debug.Log('10: Entering ',2);
95: END IF;
96:
97:
98: v_msg_prop.recipient_list := v_recipient_list;

Line 111: okc_debug.Log('1000: Leaving ',2);

107: , msgid => v_msg_handle );
108: x_msg_handle := v_msg_handle;
109:
110: IF (l_debug = 'Y') THEN
111: okc_debug.Log('1000: Leaving ',2);
112: okc_debug.Reset_Indentation;
113: END IF;
114:
115: END enqueue_message;

Line 112: okc_debug.Reset_Indentation;

108: x_msg_handle := v_msg_handle;
109:
110: IF (l_debug = 'Y') THEN
111: okc_debug.Log('1000: Leaving ',2);
112: okc_debug.Reset_Indentation;
113: END IF;
114:
115: END enqueue_message;
116:

Line 129: okc_debug.Set_Indentation(l_proc);

125: --
126:
127: BEGIN
128: IF (l_debug = 'Y') THEN
129: okc_debug.Set_Indentation(l_proc);
130: okc_debug.Log('10: Entering ',2);
131: END IF;
132:
133:

Line 130: okc_debug.Log('10: Entering ',2);

126:
127: BEGIN
128: IF (l_debug = 'Y') THEN
129: okc_debug.Set_Indentation(l_proc);
130: okc_debug.Log('10: Entering ',2);
131: END IF;
132:
133:
134: l_char_clob := system.okc_aq_msg_typ(empty_clob());

Line 144: okc_debug.Log('1000: Leaving ',2);

140: , 1
141: , p_msg );
142: x_char_clob := l_char_clob;
143: IF (l_debug = 'Y') THEN
144: okc_debug.Log('1000: Leaving ',2);
145: okc_debug.Reset_Indentation;
146: END IF;
147:
148:

Line 145: okc_debug.Reset_Indentation;

141: , p_msg );
142: x_char_clob := l_char_clob;
143: IF (l_debug = 'Y') THEN
144: okc_debug.Log('1000: Leaving ',2);
145: okc_debug.Reset_Indentation;
146: END IF;
147:
148:
149: EXCEPTION

Line 152: okc_debug.Log('2000: Leaving ',2);

148:
149: EXCEPTION
150: WHEN others THEN
151: IF (l_debug = 'Y') THEN
152: okc_debug.Log('2000: Leaving ',2);
153: okc_debug.Reset_Indentation;
154: END IF;
155: null;
156: END build_char_clob;

Line 153: okc_debug.Reset_Indentation;

149: EXCEPTION
150: WHEN others THEN
151: IF (l_debug = 'Y') THEN
152: okc_debug.Log('2000: Leaving ',2);
153: okc_debug.Reset_Indentation;
154: END IF;
155: null;
156: END build_char_clob;
157:

Line 169: okc_debug.Set_Indentation(l_proc);

165: --
166:
167: BEGIN
168: IF (l_debug = 'Y') THEN
169: okc_debug.Set_Indentation(l_proc);
170: okc_debug.Log('10: Entering ',2);
171: END IF;
172:
173:

Line 170: okc_debug.Log('10: Entering ',2);

166:
167: BEGIN
168: IF (l_debug = 'Y') THEN
169: okc_debug.Set_Indentation(l_proc);
170: okc_debug.Log('10: Entering ',2);
171: END IF;
172:
173:
174: l_clob_msg := system.okc_aq_msg_typ (empty_clob());

Line 184: okc_debug.Log('1000: Leaving ',2);

180: , l_amount
181: , 1
182: , x_char_msg);
183: IF (l_debug = 'Y') THEN
184: okc_debug.Log('1000: Leaving ',2);
185: okc_debug.Reset_Indentation;
186: END IF;
187:
188: END clob_to_char;

Line 185: okc_debug.Reset_Indentation;

181: , 1
182: , x_char_msg);
183: IF (l_debug = 'Y') THEN
184: okc_debug.Log('1000: Leaving ',2);
185: okc_debug.Reset_Indentation;
186: END IF;
187:
188: END clob_to_char;
189:

Line 200: okc_debug.Set_Indentation(l_proc);

196: --
197:
198: BEGIN
199: IF (l_debug = 'Y') THEN
200: okc_debug.Set_Indentation(l_proc);
201: okc_debug.Log('10: Entering ',2);
202: okc_debug.Log('20: p_name : '||p_name,2);
203: END IF;
204:

Line 201: okc_debug.Log('10: Entering ',2);

197:
198: BEGIN
199: IF (l_debug = 'Y') THEN
200: okc_debug.Set_Indentation(l_proc);
201: okc_debug.Log('10: Entering ',2);
202: okc_debug.Log('20: p_name : '||p_name,2);
203: END IF;
204:
205: x_name := translate (p_name, '.', '#');

Line 202: okc_debug.Log('20: p_name : '||p_name,2);

198: BEGIN
199: IF (l_debug = 'Y') THEN
200: okc_debug.Set_Indentation(l_proc);
201: okc_debug.Log('10: Entering ',2);
202: okc_debug.Log('20: p_name : '||p_name,2);
203: END IF;
204:
205: x_name := translate (p_name, '.', '#');
206:

Line 208: okc_debug.Log('50: x_name : '||x_name,2);

204:
205: x_name := translate (p_name, '.', '#');
206:
207: IF (l_debug = 'Y') THEN
208: okc_debug.Log('50: x_name : '||x_name,2);
209: okc_debug.Log('1000: Leaving ',2);
210: okc_debug.Reset_Indentation;
211: END IF;
212:

Line 209: okc_debug.Log('1000: Leaving ',2);

205: x_name := translate (p_name, '.', '#');
206:
207: IF (l_debug = 'Y') THEN
208: okc_debug.Log('50: x_name : '||x_name,2);
209: okc_debug.Log('1000: Leaving ',2);
210: okc_debug.Reset_Indentation;
211: END IF;
212:
213: END code_dots;

Line 210: okc_debug.Reset_Indentation;

206:
207: IF (l_debug = 'Y') THEN
208: okc_debug.Log('50: x_name : '||x_name,2);
209: okc_debug.Log('1000: Leaving ',2);
210: okc_debug.Reset_Indentation;
211: END IF;
212:
213: END code_dots;
214:

Line 225: okc_debug.Set_Indentation(l_proc);

221: --
222:
223: BEGIN
224: IF (l_debug = 'Y') THEN
225: okc_debug.Set_Indentation(l_proc);
226: okc_debug.Log('10: Entering ',2);
227: okc_debug.Log('20: p_name : '||p_name,2);
228: END IF;
229:

Line 226: okc_debug.Log('10: Entering ',2);

222:
223: BEGIN
224: IF (l_debug = 'Y') THEN
225: okc_debug.Set_Indentation(l_proc);
226: okc_debug.Log('10: Entering ',2);
227: okc_debug.Log('20: p_name : '||p_name,2);
228: END IF;
229:
230: x_name := translate (p_name, '#', '.');

Line 227: okc_debug.Log('20: p_name : '||p_name,2);

223: BEGIN
224: IF (l_debug = 'Y') THEN
225: okc_debug.Set_Indentation(l_proc);
226: okc_debug.Log('10: Entering ',2);
227: okc_debug.Log('20: p_name : '||p_name,2);
228: END IF;
229:
230: x_name := translate (p_name, '#', '.');
231:

Line 233: okc_debug.Log('50: x_name : '||x_name,2);

229:
230: x_name := translate (p_name, '#', '.');
231:
232: IF (l_debug = 'Y') THEN
233: okc_debug.Log('50: x_name : '||x_name,2);
234: okc_debug.Log('1000: Leaving ',2);
235: okc_debug.Reset_Indentation;
236: END IF;
237:

Line 234: okc_debug.Log('1000: Leaving ',2);

230: x_name := translate (p_name, '#', '.');
231:
232: IF (l_debug = 'Y') THEN
233: okc_debug.Log('50: x_name : '||x_name,2);
234: okc_debug.Log('1000: Leaving ',2);
235: okc_debug.Reset_Indentation;
236: END IF;
237:
238:

Line 235: okc_debug.Reset_Indentation;

231:
232: IF (l_debug = 'Y') THEN
233: okc_debug.Log('50: x_name : '||x_name,2);
234: okc_debug.Log('1000: Leaving ',2);
235: okc_debug.Reset_Indentation;
236: END IF;
237:
238:
239: END decode_dots;

Line 271: okc_debug.Set_Indentation(l_proc);

267: --
268:
269: BEGIN
270: IF (l_debug = 'Y') THEN
271: okc_debug.Set_Indentation(l_proc);
272: okc_debug.Log('10: Entering ',2);
273: END IF;
274:
275: -- Call start_activity to create savepoint, check compatibility

Line 272: okc_debug.Log('10: Entering ',2);

268:
269: BEGIN
270: IF (l_debug = 'Y') THEN
271: okc_debug.Set_Indentation(l_proc);
272: okc_debug.Log('10: Entering ',2);
273: END IF;
274:
275: -- Call start_activity to create savepoint, check compatibility
276: -- and initialize message list

Line 287: okc_debug.Log('20: l_return_status : '||l_return_status,2);

283: , x_return_status
284: );
285:
286: IF (l_debug = 'Y') THEN
287: okc_debug.Log('20: l_return_status : '||l_return_status,2);
288: END IF;
289:
290: -- Check if activity started successfully
291: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

Line 301: okc_debug.Log('50: Calling okc_xml_pvt.build_xml_clob ',2);

297: p_msg_tab.count > 0 THEN
298:
299: -- build XML clob
300: IF (l_debug = 'Y') THEN
301: okc_debug.Log('50: Calling okc_xml_pvt.build_xml_clob ',2);
302: END IF;
303:
304: okc_xml_pvt.build_xml_clob (
305: p_corrid_rec

Line 310: okc_debug.Log('55: After Call To okc_xml_pvt.build_xml_clob ',2);

306: , p_msg_tab
307: , l_xml_clob );
308:
309: IF (l_debug = 'Y') THEN
310: okc_debug.Log('55: After Call To okc_xml_pvt.build_xml_clob ',2);
311: END IF;
312:
313: END IF;
314:

Line 317: okc_debug.Log('60: Calling enqueue_message ',2);

313: END IF;
314:
315: -- enqueue message
316: IF (l_debug = 'Y') THEN
317: okc_debug.Log('60: Calling enqueue_message ',2);
318: END IF;
319:
320: enqueue_message ( l_xml_clob
321: , p_corrid_rec

Line 327: okc_debug.Log('70: After Call To enqueue_message ',2);

323: , p_delay
324: , x_msg_handle);
325:
326: IF (l_debug = 'Y') THEN
327: okc_debug.Log('70: After Call To enqueue_message ',2);
328: END IF;
329:
330: IF x_msg_handle IS NULL THEN
331: IF (l_debug = 'Y') THEN

Line 332: okc_debug.Log('100: Raising OKC_ENQUEUE_FAILED ',2);

328: END IF;
329:
330: IF x_msg_handle IS NULL THEN
331: IF (l_debug = 'Y') THEN
332: okc_debug.Log('100: Raising OKC_ENQUEUE_FAILED ',2);
333: okc_debug.Log('100: Leaving ',2);
334: okc_debug.Reset_Indentation;
335: END IF;
336: RAISE OKC_ENQUEUE_FAILED;

Line 333: okc_debug.Log('100: Leaving ',2);

329:
330: IF x_msg_handle IS NULL THEN
331: IF (l_debug = 'Y') THEN
332: okc_debug.Log('100: Raising OKC_ENQUEUE_FAILED ',2);
333: okc_debug.Log('100: Leaving ',2);
334: okc_debug.Reset_Indentation;
335: END IF;
336: RAISE OKC_ENQUEUE_FAILED;
337: END IF;

Line 334: okc_debug.Reset_Indentation;

330: IF x_msg_handle IS NULL THEN
331: IF (l_debug = 'Y') THEN
332: okc_debug.Log('100: Raising OKC_ENQUEUE_FAILED ',2);
333: okc_debug.Log('100: Leaving ',2);
334: okc_debug.Reset_Indentation;
335: END IF;
336: RAISE OKC_ENQUEUE_FAILED;
337: END IF;
338: -- end activity

Line 342: okc_debug.Log('1000: Leaving ',2);

338: -- end activity
339: OKC_API.END_ACTIVITY ( x_msg_count
340: , x_msg_data );
341: IF (l_debug = 'Y') THEN
342: okc_debug.Log('1000: Leaving ',2);
343: okc_debug.Reset_Indentation;
344: END IF;
345:
346:

Line 343: okc_debug.Reset_Indentation;

339: OKC_API.END_ACTIVITY ( x_msg_count
340: , x_msg_data );
341: IF (l_debug = 'Y') THEN
342: okc_debug.Log('1000: Leaving ',2);
343: okc_debug.Reset_Indentation;
344: END IF;
345:
346:
347: EXCEPTION

Line 358: okc_debug.Log('2000: Leaving ',2);

354: , x_msg_data
355: , '_PVT'
356: );
357: IF (l_debug = 'Y') THEN
358: okc_debug.Log('2000: Leaving ',2);
359: okc_debug.Reset_Indentation;
360: END IF;
361: WHEN OTHERS THEN
362: x_return_status := OKC_API.HANDLE_EXCEPTIONS (

Line 359: okc_debug.Reset_Indentation;

355: , '_PVT'
356: );
357: IF (l_debug = 'Y') THEN
358: okc_debug.Log('2000: Leaving ',2);
359: okc_debug.Reset_Indentation;
360: END IF;
361: WHEN OTHERS THEN
362: x_return_status := OKC_API.HANDLE_EXCEPTIONS (
363: l_api_name

Line 371: okc_debug.Log('3000: Leaving ',2);

367: , x_msg_data
368: , '_PVT'
369: );
370: IF (l_debug = 'Y') THEN
371: okc_debug.Log('3000: Leaving ',2);
372: okc_debug.Reset_Indentation;
373: END IF;
374: END send_message;
375:

Line 372: okc_debug.Reset_Indentation;

368: , '_PVT'
369: );
370: IF (l_debug = 'Y') THEN
371: okc_debug.Log('3000: Leaving ',2);
372: okc_debug.Reset_Indentation;
373: END IF;
374: END send_message;
375:
376:

Line 402: okc_debug.Set_Indentation(l_proc);

398: --
399:
400: BEGIN
401: IF (l_debug = 'Y') THEN
402: okc_debug.Set_Indentation(l_proc);
403: okc_debug.Log('10: Entering ',2);
404: END IF;
405:
406: IF p_msg IS NOT NULL THEN

Line 403: okc_debug.Log('10: Entering ',2);

399:
400: BEGIN
401: IF (l_debug = 'Y') THEN
402: okc_debug.Set_Indentation(l_proc);
403: okc_debug.Log('10: Entering ',2);
404: END IF;
405:
406: IF p_msg IS NOT NULL THEN
407: -- Call start_activity to create savepoint, check compatibility

Line 441: okc_debug.Log('1000: Leaving ',2);

437: OKC_API.END_ACTIVITY ( x_msg_count
438: , x_msg_data );
439: END IF;
440: IF (l_debug = 'Y') THEN
441: okc_debug.Log('1000: Leaving ',2);
442: okc_debug.Reset_Indentation;
443: END IF;
444:
445:

Line 442: okc_debug.Reset_Indentation;

438: , x_msg_data );
439: END IF;
440: IF (l_debug = 'Y') THEN
441: okc_debug.Log('1000: Leaving ',2);
442: okc_debug.Reset_Indentation;
443: END IF;
444:
445:
446: EXCEPTION

Line 457: okc_debug.Log('2000: Leaving ',2);

453: , x_msg_data
454: , '_PVT'
455: );
456: IF (l_debug = 'Y') THEN
457: okc_debug.Log('2000: Leaving ',2);
458: okc_debug.Reset_Indentation;
459: END IF;
460: WHEN OTHERS THEN
461: x_return_status := OKC_API.HANDLE_EXCEPTIONS (

Line 458: okc_debug.Reset_Indentation;

454: , '_PVT'
455: );
456: IF (l_debug = 'Y') THEN
457: okc_debug.Log('2000: Leaving ',2);
458: okc_debug.Reset_Indentation;
459: END IF;
460: WHEN OTHERS THEN
461: x_return_status := OKC_API.HANDLE_EXCEPTIONS (
462: l_api_name

Line 470: okc_debug.Log('3000: Leaving ',2);

466: , x_msg_data
467: , '_PVT'
468: );
469: IF (l_debug = 'Y') THEN
470: okc_debug.Log('3000: Leaving ',2);
471: okc_debug.Reset_Indentation;
472: END IF;
473: END send_message;*/
474:

Line 471: okc_debug.Reset_Indentation;

467: , '_PVT'
468: );
469: IF (l_debug = 'Y') THEN
470: okc_debug.Log('3000: Leaving ',2);
471: okc_debug.Reset_Indentation;
472: END IF;
473: END send_message;*/
474:
475: -- This function checks for messages of correlation 'SHUTDOWN'

Line 515: -- okc_debug.Set_Indentation(l_proc);

511: l_proc varchar2(72) := ' OKC_AQ_PVT.'||'shutdown_event_listener';
512: --
513:
514: BEGIN
515: -- okc_debug.Set_Indentation(l_proc);
516: -- okc_debug.Log('10: Entering ',2);
517:
518: IF queue_cur%ISOPEN THEN
519: CLOSE queue_cur;

Line 516: -- okc_debug.Log('10: Entering ',2);

512: --
513:
514: BEGIN
515: -- okc_debug.Set_Indentation(l_proc);
516: -- okc_debug.Log('10: Entering ',2);
517:
518: IF queue_cur%ISOPEN THEN
519: CLOSE queue_cur;
520: END IF;

Line 536: -- okc_debug.Log('1000: Leaving ',2);

532: , msgid => l_msg_handle );
533: commit;
534: CLOSE queue_cur;
535:
536: -- okc_debug.Log('1000: Leaving ',2);
537: -- okc_debug.Reset_Indentation;
538: RETURN(TRUE);
539: ELSE
540: CLOSE queue_cur;

Line 537: -- okc_debug.Reset_Indentation;

533: commit;
534: CLOSE queue_cur;
535:
536: -- okc_debug.Log('1000: Leaving ',2);
537: -- okc_debug.Reset_Indentation;
538: RETURN(TRUE);
539: ELSE
540: CLOSE queue_cur;
541: -- okc_debug.Log('2000: Leaving ',2);

Line 541: -- okc_debug.Log('2000: Leaving ',2);

537: -- okc_debug.Reset_Indentation;
538: RETURN(TRUE);
539: ELSE
540: CLOSE queue_cur;
541: -- okc_debug.Log('2000: Leaving ',2);
542: -- okc_debug.Reset_Indentation;
543: RETURN(FALSE);
544: END IF;
545:

Line 542: -- okc_debug.Reset_Indentation;

538: RETURN(TRUE);
539: ELSE
540: CLOSE queue_cur;
541: -- okc_debug.Log('2000: Leaving ',2);
542: -- okc_debug.Reset_Indentation;
543: RETURN(FALSE);
544: END IF;
545:
546: END shutdown_event_listener;

Line 587: -- okc_debug.Set_Indentation(l_proc);

583: l_proc varchar2(72) := ' OKC_AQ_PVT.'||'shutdown_outcome_listener';
584: --
585:
586: BEGIN
587: -- okc_debug.Set_Indentation(l_proc);
588: -- okc_debug.Log('10: Entering ',2);
589:
590: IF queue_cur%ISOPEN THEN
591: CLOSE queue_cur;

Line 588: -- okc_debug.Log('10: Entering ',2);

584: --
585:
586: BEGIN
587: -- okc_debug.Set_Indentation(l_proc);
588: -- okc_debug.Log('10: Entering ',2);
589:
590: IF queue_cur%ISOPEN THEN
591: CLOSE queue_cur;
592: END IF;

Line 609: -- okc_debug.Log('1000: Leaving ',2);

605: , msgid => l_msg_handle );
606: commit;
607: CLOSE queue_cur;
608:
609: -- okc_debug.Log('1000: Leaving ',2);
610: -- okc_debug.Reset_Indentation;
611: RETURN(TRUE);
612: ELSE
613: CLOSE queue_cur;

Line 610: -- okc_debug.Reset_Indentation;

606: commit;
607: CLOSE queue_cur;
608:
609: -- okc_debug.Log('1000: Leaving ',2);
610: -- okc_debug.Reset_Indentation;
611: RETURN(TRUE);
612: ELSE
613: CLOSE queue_cur;
614: -- okc_debug.Log('2000: Leaving ',2);

Line 614: -- okc_debug.Log('2000: Leaving ',2);

610: -- okc_debug.Reset_Indentation;
611: RETURN(TRUE);
612: ELSE
613: CLOSE queue_cur;
614: -- okc_debug.Log('2000: Leaving ',2);
615: -- okc_debug.Reset_Indentation;
616: RETURN(FALSE);
617: END IF;
618:

Line 615: -- okc_debug.Reset_Indentation;

611: RETURN(TRUE);
612: ELSE
613: CLOSE queue_cur;
614: -- okc_debug.Log('2000: Leaving ',2);
615: -- okc_debug.Reset_Indentation;
616: RETURN(FALSE);
617: END IF;
618:
619: END shutdown_outcome_listener;

Line 648: -- okc_debug.Set_Indentation(l_proc);

644: l_proc varchar2(72) := ' OKC_AQ_PVT.'||'listen_event';
645: --
646:
647: BEGIN
648: -- okc_debug.Set_Indentation(l_proc);
649: -- okc_debug.Log('10: Entering ',2);
650:
651: retcode := 0;
652: l_index := 1;

Line 649: -- okc_debug.Log('10: Entering ',2);

645: --
646:
647: BEGIN
648: -- okc_debug.Set_Indentation(l_proc);
649: -- okc_debug.Log('10: Entering ',2);
650:
651: retcode := 0;
652: l_index := 1;
653:

Line 654: -- okc_debug.Log('50: Before subscriber LOOP',2);

650:
651: retcode := 0;
652: l_index := 1;
653:
654: -- okc_debug.Log('50: Before subscriber LOOP',2);
655:
656: FOR r_subscriber IN c_subscriber LOOP
657: l_agent_list(l_index) := SYS.aq$_agent ( r_subscriber.name
658: , OKC_AQ_PVT.g_event_queue_name

Line 663: -- okc_debug.Log('60: After subscriber LOOP',2);

659: , NULL );
660: l_index := l_index + 1;
661: END LOOP;
662:
663: -- okc_debug.Log('60: After subscriber LOOP',2);
664:
665:
666: -- changed to unconditional loop
667:

Line 668: -- okc_debug.Log('70: Before unconditional LOOP',2);

664:
665:
666: -- changed to unconditional loop
667:
668: -- okc_debug.Log('70: Before unconditional LOOP',2);
669: /* LOOP -- limit loop in order to enable faster shutdown of listeners */
670: l_listener_iterations := nvl(fnd_profile.value('OKC_LISTEN_EVENT'),100);
671:
672: FOR i IN 1..l_listener_iterations LOOP

Line 697: -- okc_debug.Log('70: After unconditional LOOP',2);

693: /* END IF; bug 2258913 */
694: /* DBMS_LOCK.sleep (p_sleep ); */
695: END LOOP;
696:
697: -- okc_debug.Log('70: After unconditional LOOP',2);
698: -- okc_debug.Log('1000: Leaving ',2);
699: -- okc_debug.Reset_Indentation;
700:
701:

Line 698: -- okc_debug.Log('1000: Leaving ',2);

694: /* DBMS_LOCK.sleep (p_sleep ); */
695: END LOOP;
696:
697: -- okc_debug.Log('70: After unconditional LOOP',2);
698: -- okc_debug.Log('1000: Leaving ',2);
699: -- okc_debug.Reset_Indentation;
700:
701:
702: exception

Line 699: -- okc_debug.Reset_Indentation;

695: END LOOP;
696:
697: -- okc_debug.Log('70: After unconditional LOOP',2);
698: -- okc_debug.Log('1000: Leaving ',2);
699: -- okc_debug.Reset_Indentation;
700:
701:
702: exception
703: when others then

Line 706: -- okc_debug.Log('2000: errbuf : '||errbuf,2);

702: exception
703: when others then
704: retcode := 2;
705: errbuf := substr(sqlerrm,1,250);
706: -- okc_debug.Log('2000: errbuf : '||errbuf,2);
707: -- okc_debug.Log('2000: Leaving ',2);
708: -- okc_debug.Reset_Indentation;
709: END listen_event;
710:

Line 707: -- okc_debug.Log('2000: Leaving ',2);

703: when others then
704: retcode := 2;
705: errbuf := substr(sqlerrm,1,250);
706: -- okc_debug.Log('2000: errbuf : '||errbuf,2);
707: -- okc_debug.Log('2000: Leaving ',2);
708: -- okc_debug.Reset_Indentation;
709: END listen_event;
710:
711: PROCEDURE listen_outcome(

Line 708: -- okc_debug.Reset_Indentation;

704: retcode := 2;
705: errbuf := substr(sqlerrm,1,250);
706: -- okc_debug.Log('2000: errbuf : '||errbuf,2);
707: -- okc_debug.Log('2000: Leaving ',2);
708: -- okc_debug.Reset_Indentation;
709: END listen_event;
710:
711: PROCEDURE listen_outcome(
712: errbuf OUT NOCOPY VARCHAR2

Line 740: -- okc_debug.Set_Indentation(l_proc);

736: l_proc varchar2(72) := ' OKC_AQ_PVT.'||'listen_outcome';
737: --
738:
739: BEGIN
740: -- okc_debug.Set_Indentation(l_proc);
741: -- okc_debug.Log('10: Entering ',2);
742:
743: retcode := 0;
744: l_index := 1;

Line 741: -- okc_debug.Log('10: Entering ',2);

737: --
738:
739: BEGIN
740: -- okc_debug.Set_Indentation(l_proc);
741: -- okc_debug.Log('10: Entering ',2);
742:
743: retcode := 0;
744: l_index := 1;
745:

Line 746: -- okc_debug.Log('20: Before subscriber LOOP',2);

742:
743: retcode := 0;
744: l_index := 1;
745:
746: -- okc_debug.Log('20: Before subscriber LOOP',2);
747:
748: FOR r_subscriber IN c_subscriber LOOP
749: l_agent_list(l_index) := SYS.aq$_agent ( r_subscriber.name
750: , OKC_AQ_PVT.g_outcome_queue_name

Line 753: -- okc_debug.Log('21: Index : '||l_index,2);

749: l_agent_list(l_index) := SYS.aq$_agent ( r_subscriber.name
750: , OKC_AQ_PVT.g_outcome_queue_name
751: , NULL );
752:
753: -- okc_debug.Log('21: Index : '||l_index,2);
754:
755: l_index := l_index + 1;
756: END LOOP;
757:

Line 758: -- okc_debug.Log('30: After subscriber LOOP',2);

754:
755: l_index := l_index + 1;
756: END LOOP;
757:
758: -- okc_debug.Log('30: After subscriber LOOP',2);
759:
760: -- okc_debug.Log('40: Before unconditional LOOP',2);
761:
762: l_listener_iterations := nvl(fnd_profile.value('OKC_LISTEN_OUTCOME'),100);

Line 760: -- okc_debug.Log('40: Before unconditional LOOP',2);

756: END LOOP;
757:
758: -- okc_debug.Log('30: After subscriber LOOP',2);
759:
760: -- okc_debug.Log('40: Before unconditional LOOP',2);
761:
762: l_listener_iterations := nvl(fnd_profile.value('OKC_LISTEN_OUTCOME'),100);
763: /* changed to unconditional loop
764: Changed to conditional loop to allow faster shutdown of listeners

Line 774: okc_debug.Log('45: Inside unconditional LOOP - exiting ',2);

770: Shutdown process no longer needed as listener no longer runs infinately.
771:
772: IF shutdown_outcome_listener(OKC_AQ_PVT.g_outcome_queue_name) THEN
773: IF (l_debug = 'Y') THEN
774: okc_debug.Log('45: Inside unconditional LOOP - exiting ',2);
775: END IF;
776: EXIT;
777: ELSE
778: */

Line 779: -- okc_debug.Log('46: Inside unconditional LOOP at 46 ',2);

775: END IF;
776: EXIT;
777: ELSE
778: */
779: -- okc_debug.Log('46: Inside unconditional LOOP at 46 ',2);
780: BEGIN
781: -- okc_debug.Log('52: Calling DBMS_AQ.listen',2);
782:
783: DBMS_AQ.listen ( agent_list => l_agent_list

Line 781: -- okc_debug.Log('52: Calling DBMS_AQ.listen',2);

777: ELSE
778: */
779: -- okc_debug.Log('46: Inside unconditional LOOP at 46 ',2);
780: BEGIN
781: -- okc_debug.Log('52: Calling DBMS_AQ.listen',2);
782:
783: DBMS_AQ.listen ( agent_list => l_agent_list
784: , wait => p_wait
785: , agent => l_agent );

Line 787: -- okc_debug.Log('53: Calling decode_dots',2);

783: DBMS_AQ.listen ( agent_list => l_agent_list
784: , wait => p_wait
785: , agent => l_agent );
786:
787: -- okc_debug.Log('53: Calling decode_dots',2);
788:
789: decode_dots ( l_agent.name, l_procedure );
790:
791: -- okc_debug.Log('54: After Calling decode_dots',2);

Line 791: -- okc_debug.Log('54: After Calling decode_dots',2);

787: -- okc_debug.Log('53: Calling decode_dots',2);
788:
789: decode_dots ( l_agent.name, l_procedure );
790:
791: -- okc_debug.Log('54: After Calling decode_dots',2);
792:
793: execute immediate 'begin '||l_procedure||'; end;';
794:
795: EXCEPTION

Line 804: -- okc_debug.Log('50: After unconditional LOOP',2);

800: /* END IF; bug 2258913 */
801: /* DBMS_LOCK.sleep (p_sleep ); */
802: END LOOP;
803:
804: -- okc_debug.Log('50: After unconditional LOOP',2);
805:
806: -- okc_debug.Log('1000: Leaving ',2);
807: -- okc_debug.Reset_Indentation;
808:

Line 806: -- okc_debug.Log('1000: Leaving ',2);

802: END LOOP;
803:
804: -- okc_debug.Log('50: After unconditional LOOP',2);
805:
806: -- okc_debug.Log('1000: Leaving ',2);
807: -- okc_debug.Reset_Indentation;
808:
809:
810: exception

Line 807: -- okc_debug.Reset_Indentation;

803:
804: -- okc_debug.Log('50: After unconditional LOOP',2);
805:
806: -- okc_debug.Log('1000: Leaving ',2);
807: -- okc_debug.Reset_Indentation;
808:
809:
810: exception
811: when others then

Line 814: -- okc_debug.Log('2000: Error : '||errbuf,2);

810: exception
811: when others then
812: retcode := 2;
813: errbuf := substr(sqlerrm,1,250);
814: -- okc_debug.Log('2000: Error : '||errbuf,2);
815: -- okc_debug.Log('2000: Leaving ',2);
816: -- okc_debug.Reset_Indentation;
817: END listen_outcome;
818:

Line 815: -- okc_debug.Log('2000: Leaving ',2);

811: when others then
812: retcode := 2;
813: errbuf := substr(sqlerrm,1,250);
814: -- okc_debug.Log('2000: Error : '||errbuf,2);
815: -- okc_debug.Log('2000: Leaving ',2);
816: -- okc_debug.Reset_Indentation;
817: END listen_outcome;
818:
819:

Line 816: -- okc_debug.Reset_Indentation;

812: retcode := 2;
813: errbuf := substr(sqlerrm,1,250);
814: -- okc_debug.Log('2000: Error : '||errbuf,2);
815: -- okc_debug.Log('2000: Leaving ',2);
816: -- okc_debug.Reset_Indentation;
817: END listen_outcome;
818:
819:
820: PROCEDURE dequeue_event

Line 864: okc_debug.Set_Indentation(l_proc);

860:
861: BEGIN
862:
863: IF (l_debug = 'Y') THEN
864: okc_debug.Set_Indentation(l_proc);
865: okc_debug.Log('10: Entering ',2);
866: END IF;
867:
868: -- Call start_activity to create savepoint, check compatibility

Line 865: okc_debug.Log('10: Entering ',2);

861: BEGIN
862:
863: IF (l_debug = 'Y') THEN
864: okc_debug.Set_Indentation(l_proc);
865: okc_debug.Log('10: Entering ',2);
866: END IF;
867:
868: -- Call start_activity to create savepoint, check compatibility
869: -- and initialize message list

Line 879: okc_debug.Log('20: l_return_status : '||l_return_status,2);

875: , '_PVT'
876: , x_return_status
877: );
878: IF (l_debug = 'Y') THEN
879: okc_debug.Log('20: l_return_status : '||l_return_status,2);
880: END IF;
881:
882: -- Check if activity started successfully
883: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

Line 898: okc_debug.Log('30: Calling DBMS_AQ.dequeue with following parameters',2);

894: l_dq_options.visibility := dbms_aq.on_commit;
895:
896:
897: IF (l_debug = 'Y') THEN
898: okc_debug.Log('30: Calling DBMS_AQ.dequeue with following parameters',2);
899: okc_debug.Log('30: queue_name : '||OKC_AQ_PVT.g_event_queue_name,2);
900: END IF;
901:
902: -- get the message from the queue

Line 899: okc_debug.Log('30: queue_name : '||OKC_AQ_PVT.g_event_queue_name,2);

895:
896:
897: IF (l_debug = 'Y') THEN
898: okc_debug.Log('30: Calling DBMS_AQ.dequeue with following parameters',2);
899: okc_debug.Log('30: queue_name : '||OKC_AQ_PVT.g_event_queue_name,2);
900: END IF;
901:
902: -- get the message from the queue
903: DBMS_AQ.dequeue ( queue_name => OKC_AQ_PVT.g_event_queue_name

Line 910: okc_debug.Log('40: After Call to DBMS_AQ.dequeue',2);

906: , payload => l_msg
907: , msgid => l_msg_handle );
908:
909: IF (l_debug = 'Y') THEN
910: okc_debug.Log('40: After Call to DBMS_AQ.dequeue',2);
911: END IF;
912:
913: -- if the payload is null then remove message from the queue and commit
914: IF l_msg IS NULL THEN

Line 926: okc_debug.Log('50: Calling OKC_XML_PVT.get_element_vals ',2);

922: raise OKC_REMOVE_MSG;
923: END IF;
924:
925: IF (l_debug = 'Y') THEN
926: okc_debug.Log('50: Calling OKC_XML_PVT.get_element_vals ',2);
927: END IF;
928:
929: -- convert the clob message to a table of element names and values
930: OKC_XML_PVT.get_element_vals ( l_msg

Line 939: okc_debug.Log('60: Calling OKC_CONDITION_EVAL_PUB.evaluate_condition ',2);

935: FETCH acn_cur INTO acn_rec;
936: l_acn_id := acn_rec.id;
937:
938: IF (l_debug = 'Y') THEN
939: okc_debug.Log('60: Calling OKC_CONDITION_EVAL_PUB.evaluate_condition ',2);
940: okc_debug.Log('60: l_acn_id : '||l_acn_id,2);
941: END IF;
942:
943: OKC_CONDITION_EVAL_PUB.evaluate_condition (

Line 940: okc_debug.Log('60: l_acn_id : '||l_acn_id,2);

936: l_acn_id := acn_rec.id;
937:
938: IF (l_debug = 'Y') THEN
939: okc_debug.Log('60: Calling OKC_CONDITION_EVAL_PUB.evaluate_condition ',2);
940: okc_debug.Log('60: l_acn_id : '||l_acn_id,2);
941: END IF;
942:
943: OKC_CONDITION_EVAL_PUB.evaluate_condition (
944: p_api_version => 1.0,

Line 953: okc_debug.Log('70: After Call To OKC_CONDITION_EVAL_PUB.evaluate_condition ',2);

949: p_msg_tab =>l_msg_tab
950: );
951:
952: IF (l_debug = 'Y') THEN
953: okc_debug.Log('70: After Call To OKC_CONDITION_EVAL_PUB.evaluate_condition ',2);
954: okc_debug.Log('70: l_return_status : '||l_return_status,2);
955: END IF;
956:
957: -- if evaluation is successfull then remove message from the queue

Line 954: okc_debug.Log('70: l_return_status : '||l_return_status,2);

950: );
951:
952: IF (l_debug = 'Y') THEN
953: okc_debug.Log('70: After Call To OKC_CONDITION_EVAL_PUB.evaluate_condition ',2);
954: okc_debug.Log('70: l_return_status : '||l_return_status,2);
955: END IF;
956:
957: -- if evaluation is successfull then remove message from the queue
958: -- and commit the transaction

Line 997: okc_debug.Log('100: l_msg_count : '||l_msg_count,2);

993: OKC_API.END_ACTIVITY ( l_msg_count
994: , l_msg_data );
995:
996: IF (l_debug = 'Y') THEN
997: okc_debug.Log('100: l_msg_count : '||l_msg_count,2);
998: okc_debug.Log('100: l_msg_data : '||l_msg_data,2);
999: END IF;
1000:
1001: IF (l_debug = 'Y') THEN

Line 998: okc_debug.Log('100: l_msg_data : '||l_msg_data,2);

994: , l_msg_data );
995:
996: IF (l_debug = 'Y') THEN
997: okc_debug.Log('100: l_msg_count : '||l_msg_count,2);
998: okc_debug.Log('100: l_msg_data : '||l_msg_data,2);
999: END IF;
1000:
1001: IF (l_debug = 'Y') THEN
1002: okc_debug.Log('1000: Leaving ',2);

Line 1002: okc_debug.Log('1000: Leaving ',2);

998: okc_debug.Log('100: l_msg_data : '||l_msg_data,2);
999: END IF;
1000:
1001: IF (l_debug = 'Y') THEN
1002: okc_debug.Log('1000: Leaving ',2);
1003: okc_debug.Reset_Indentation;
1004: END IF;
1005:
1006:

Line 1003: okc_debug.Reset_Indentation;

999: END IF;
1000:
1001: IF (l_debug = 'Y') THEN
1002: okc_debug.Log('1000: Leaving ',2);
1003: okc_debug.Reset_Indentation;
1004: END IF;
1005:
1006:
1007: EXCEPTION

Line 1011: okc_debug.Log('2000: Leaving ',2);

1007: EXCEPTION
1008:
1009: WHEN e_dequeue_timeout THEN
1010: IF (l_debug = 'Y') THEN
1011: okc_debug.Log('2000: Leaving ',2);
1012: okc_debug.Reset_Indentation;
1013: END IF;
1014: null;
1015: WHEN OKC_REMOVE_MSG THEN

Line 1012: okc_debug.Reset_Indentation;

1008:
1009: WHEN e_dequeue_timeout THEN
1010: IF (l_debug = 'Y') THEN
1011: okc_debug.Log('2000: Leaving ',2);
1012: okc_debug.Reset_Indentation;
1013: END IF;
1014: null;
1015: WHEN OKC_REMOVE_MSG THEN
1016: l_dq_options.dequeue_mode := dbms_aq.REMOVE_NODATA;

Line 1037: okc_debug.Log('3000: Leaving ',2);

1033: p_msg_count => l_msg_count,
1034: p_msg_data => l_msg_data
1035: );
1036: IF (l_debug = 'Y') THEN
1037: okc_debug.Log('3000: Leaving ',2);
1038: okc_debug.Reset_Indentation;
1039: END IF;
1040:
1041: WHEN OTHERS THEN

Line 1038: okc_debug.Reset_Indentation;

1034: p_msg_data => l_msg_data
1035: );
1036: IF (l_debug = 'Y') THEN
1037: okc_debug.Log('3000: Leaving ',2);
1038: okc_debug.Reset_Indentation;
1039: END IF;
1040:
1041: WHEN OTHERS THEN
1042: x_return_status := OKC_API.HANDLE_EXCEPTIONS (

Line 1063: okc_debug.Log('4000: Leaving ',2);

1059: p_msg_count => l_msg_count,
1060: p_msg_data => l_msg_data
1061: );
1062: IF (l_debug = 'Y') THEN
1063: okc_debug.Log('4000: Leaving ',2);
1064: okc_debug.Reset_Indentation;
1065: END IF;
1066: END dequeue_event;
1067:

Line 1064: okc_debug.Reset_Indentation;

1060: p_msg_data => l_msg_data
1061: );
1062: IF (l_debug = 'Y') THEN
1063: okc_debug.Log('4000: Leaving ',2);
1064: okc_debug.Reset_Indentation;
1065: END IF;
1066: END dequeue_event;
1067:
1068:

Line 1108: okc_debug.Set_Indentation(l_proc);

1104: --
1105:
1106: BEGIN
1107: IF (l_debug = 'Y') THEN
1108: okc_debug.Set_Indentation(l_proc);
1109: okc_debug.Log('10: Entering ',2);
1110: END IF;
1111:
1112:

Line 1109: okc_debug.Log('10: Entering ',2);

1105:
1106: BEGIN
1107: IF (l_debug = 'Y') THEN
1108: okc_debug.Set_Indentation(l_proc);
1109: okc_debug.Log('10: Entering ',2);
1110: END IF;
1111:
1112:
1113: -- Call start_activity to create savepoint, check compatibility

Line 1216: okc_debug.Log('1000: Leaving ',2);

1212: OKC_API.END_ACTIVITY ( l_msg_count
1213: , l_msg_data );
1214:
1215: IF (l_debug = 'Y') THEN
1216: okc_debug.Log('1000: Leaving ',2);
1217: okc_debug.Reset_Indentation;
1218: END IF;
1219:
1220:

Line 1217: okc_debug.Reset_Indentation;

1213: , l_msg_data );
1214:
1215: IF (l_debug = 'Y') THEN
1216: okc_debug.Log('1000: Leaving ',2);
1217: okc_debug.Reset_Indentation;
1218: END IF;
1219:
1220:
1221: EXCEPTION

Line 1225: okc_debug.Log('2000: Leaving ',2);

1221: EXCEPTION
1222:
1223: WHEN e_dequeue_timeout THEN
1224: IF (l_debug = 'Y') THEN
1225: okc_debug.Log('2000: Leaving ',2);
1226: okc_debug.Reset_Indentation;
1227: END IF;
1228: null;
1229: WHEN OKC_REMOVE_MSG THEN

Line 1226: okc_debug.Reset_Indentation;

1222:
1223: WHEN e_dequeue_timeout THEN
1224: IF (l_debug = 'Y') THEN
1225: okc_debug.Log('2000: Leaving ',2);
1226: okc_debug.Reset_Indentation;
1227: END IF;
1228: null;
1229: WHEN OKC_REMOVE_MSG THEN
1230: l_dq_options.dequeue_mode := dbms_aq.REMOVE_NODATA;

Line 1251: okc_debug.Log('3000: Leaving ',2);

1247: p_msg_count => l_msg_count,
1248: p_msg_data => l_msg_data
1249: );
1250: IF (l_debug = 'Y') THEN
1251: okc_debug.Log('3000: Leaving ',2);
1252: okc_debug.Reset_Indentation;
1253: END IF;
1254:
1255: WHEN OTHERS THEN

Line 1252: okc_debug.Reset_Indentation;

1248: p_msg_data => l_msg_data
1249: );
1250: IF (l_debug = 'Y') THEN
1251: okc_debug.Log('3000: Leaving ',2);
1252: okc_debug.Reset_Indentation;
1253: END IF;
1254:
1255: WHEN OTHERS THEN
1256: x_return_status := OKC_API.HANDLE_EXCEPTIONS (

Line 1277: okc_debug.Log('4000: Leaving ',2);

1273: p_msg_count => l_msg_count,
1274: p_msg_data => l_msg_data
1275: );
1276: IF (l_debug = 'Y') THEN
1277: okc_debug.Log('4000: Leaving ',2);
1278: okc_debug.Reset_Indentation;
1279: END IF;
1280: END dequeue_date_event;
1281:

Line 1278: okc_debug.Reset_Indentation;

1274: p_msg_data => l_msg_data
1275: );
1276: IF (l_debug = 'Y') THEN
1277: okc_debug.Log('4000: Leaving ',2);
1278: okc_debug.Reset_Indentation;
1279: END IF;
1280: END dequeue_date_event;
1281:
1282: PROCEDURE dequeue_outcome

Line 1320: okc_debug.Set_Indentation(l_proc);

1316: --
1317:
1318: BEGIN
1319: IF (l_debug = 'Y') THEN
1320: okc_debug.Set_Indentation(l_proc);
1321: okc_debug.Log('10: Entering ',2);
1322: END IF;
1323:
1324:

Line 1321: okc_debug.Log('10: Entering ',2);

1317:
1318: BEGIN
1319: IF (l_debug = 'Y') THEN
1320: okc_debug.Set_Indentation(l_proc);
1321: okc_debug.Log('10: Entering ',2);
1322: END IF;
1323:
1324:
1325: -- Call start_activity to create savepoint, check compatibility

Line 1343: okc_debug.Log('50: Calling code_dots ',2);

1339: RAISE OKC_API.G_EXCEPTION_ERROR;
1340: END IF;
1341:
1342: IF (l_debug = 'Y') THEN
1343: okc_debug.Log('50: Calling code_dots ',2);
1344: END IF;
1345:
1346: -- convert dots to hashes to make sub name legal
1347: code_dots ('OKC_AQ_PVT.DEQUEUE_OUTCOME', l_sub_name);

Line 1357: okc_debug.Log('100: Calling DBMS_AQ.dequeue',2);

1353: l_dq_options.visibility := dbms_aq.ON_COMMIT;
1354:
1355:
1356: IF (l_debug = 'Y') THEN
1357: okc_debug.Log('100: Calling DBMS_AQ.dequeue',2);
1358: END IF;
1359:
1360: -- get the message from the queue
1361:

Line 1369: okc_debug.Log('110: After Calling DBMS_AQ.dequeue',2);

1365: , payload => l_msg
1366: , msgid => l_msg_handle );
1367:
1368: IF (l_debug = 'Y') THEN
1369: okc_debug.Log('110: After Calling DBMS_AQ.dequeue',2);
1370: END IF;
1371:
1372: IF l_msg IS NULL THEN
1373: OKC_API.SET_MESSAGE(p_app_name => g_app_name

Line 1384: okc_debug.Log('120: Calling OKC_XML_PVT.get_element_vals ',2);

1380: raise OKC_REMOVE_MSG;
1381: END IF;
1382:
1383: IF (l_debug = 'Y') THEN
1384: okc_debug.Log('120: Calling OKC_XML_PVT.get_element_vals ',2);
1385: END IF;
1386:
1387: -- converts message from clob to table of element names and values
1388: OKC_XML_PVT.get_element_vals ( l_msg

Line 1393: okc_debug.Log('130: After Calling OKC_XML_PVT.get_element_vals ',2);

1389: , l_msg_tab
1390: , l_corrid );
1391:
1392: IF (l_debug = 'Y') THEN
1393: okc_debug.Log('130: After Calling OKC_XML_PVT.get_element_vals ',2);
1394: okc_debug.Log('130: l_corrid.corrid : '||l_corrid.corrid,2);
1395: okc_debug.Log('130: l_msg_tab.count : '||l_msg_tab.count,2);
1396: END IF;
1397:

Line 1394: okc_debug.Log('130: l_corrid.corrid : '||l_corrid.corrid,2);

1390: , l_corrid );
1391:
1392: IF (l_debug = 'Y') THEN
1393: okc_debug.Log('130: After Calling OKC_XML_PVT.get_element_vals ',2);
1394: okc_debug.Log('130: l_corrid.corrid : '||l_corrid.corrid,2);
1395: okc_debug.Log('130: l_msg_tab.count : '||l_msg_tab.count,2);
1396: END IF;
1397:
1398: -- call the outcome APIs

Line 1395: okc_debug.Log('130: l_msg_tab.count : '||l_msg_tab.count,2);

1391:
1392: IF (l_debug = 'Y') THEN
1393: okc_debug.Log('130: After Calling OKC_XML_PVT.get_element_vals ',2);
1394: okc_debug.Log('130: l_corrid.corrid : '||l_corrid.corrid,2);
1395: okc_debug.Log('130: l_msg_tab.count : '||l_msg_tab.count,2);
1396: END IF;
1397:
1398: -- call the outcome APIs
1399: IF l_corrid.corrid IS NOT NULL AND

Line 1443: okc_debug.Log('500: l_msg_count : '||l_msg_count,2);

1439: , l_msg_data );
1440:
1441:
1442: IF (l_debug = 'Y') THEN
1443: okc_debug.Log('500: l_msg_count : '||l_msg_count,2);
1444: okc_debug.Log('500: l_msg_data : '||l_msg_data,2);
1445: okc_debug.Log('1000: Leaving ',2);
1446: okc_debug.Reset_Indentation;
1447: END IF;

Line 1444: okc_debug.Log('500: l_msg_data : '||l_msg_data,2);

1440:
1441:
1442: IF (l_debug = 'Y') THEN
1443: okc_debug.Log('500: l_msg_count : '||l_msg_count,2);
1444: okc_debug.Log('500: l_msg_data : '||l_msg_data,2);
1445: okc_debug.Log('1000: Leaving ',2);
1446: okc_debug.Reset_Indentation;
1447: END IF;
1448:

Line 1445: okc_debug.Log('1000: Leaving ',2);

1441:
1442: IF (l_debug = 'Y') THEN
1443: okc_debug.Log('500: l_msg_count : '||l_msg_count,2);
1444: okc_debug.Log('500: l_msg_data : '||l_msg_data,2);
1445: okc_debug.Log('1000: Leaving ',2);
1446: okc_debug.Reset_Indentation;
1447: END IF;
1448:
1449:

Line 1446: okc_debug.Reset_Indentation;

1442: IF (l_debug = 'Y') THEN
1443: okc_debug.Log('500: l_msg_count : '||l_msg_count,2);
1444: okc_debug.Log('500: l_msg_data : '||l_msg_data,2);
1445: okc_debug.Log('1000: Leaving ',2);
1446: okc_debug.Reset_Indentation;
1447: END IF;
1448:
1449:
1450: EXCEPTION

Line 1454: okc_debug.Log('2000: e_dequeue_timeout EXCEPTION',2);

1450: EXCEPTION
1451:
1452: WHEN e_dequeue_timeout THEN
1453: IF (l_debug = 'Y') THEN
1454: okc_debug.Log('2000: e_dequeue_timeout EXCEPTION',2);
1455: okc_debug.Log('2000: l_msg_count : '||l_msg_count,2);
1456: okc_debug.Log('2000: l_msg_data : '||l_msg_data,2);
1457: okc_debug.Log('2000: Leaving ',2);
1458: okc_debug.Reset_Indentation;

Line 1455: okc_debug.Log('2000: l_msg_count : '||l_msg_count,2);

1451:
1452: WHEN e_dequeue_timeout THEN
1453: IF (l_debug = 'Y') THEN
1454: okc_debug.Log('2000: e_dequeue_timeout EXCEPTION',2);
1455: okc_debug.Log('2000: l_msg_count : '||l_msg_count,2);
1456: okc_debug.Log('2000: l_msg_data : '||l_msg_data,2);
1457: okc_debug.Log('2000: Leaving ',2);
1458: okc_debug.Reset_Indentation;
1459: END IF;

Line 1456: okc_debug.Log('2000: l_msg_data : '||l_msg_data,2);

1452: WHEN e_dequeue_timeout THEN
1453: IF (l_debug = 'Y') THEN
1454: okc_debug.Log('2000: e_dequeue_timeout EXCEPTION',2);
1455: okc_debug.Log('2000: l_msg_count : '||l_msg_count,2);
1456: okc_debug.Log('2000: l_msg_data : '||l_msg_data,2);
1457: okc_debug.Log('2000: Leaving ',2);
1458: okc_debug.Reset_Indentation;
1459: END IF;
1460: null;

Line 1457: okc_debug.Log('2000: Leaving ',2);

1453: IF (l_debug = 'Y') THEN
1454: okc_debug.Log('2000: e_dequeue_timeout EXCEPTION',2);
1455: okc_debug.Log('2000: l_msg_count : '||l_msg_count,2);
1456: okc_debug.Log('2000: l_msg_data : '||l_msg_data,2);
1457: okc_debug.Log('2000: Leaving ',2);
1458: okc_debug.Reset_Indentation;
1459: END IF;
1460: null;
1461: WHEN OKC_REMOVE_MSG THEN

Line 1458: okc_debug.Reset_Indentation;

1454: okc_debug.Log('2000: e_dequeue_timeout EXCEPTION',2);
1455: okc_debug.Log('2000: l_msg_count : '||l_msg_count,2);
1456: okc_debug.Log('2000: l_msg_data : '||l_msg_data,2);
1457: okc_debug.Log('2000: Leaving ',2);
1458: okc_debug.Reset_Indentation;
1459: END IF;
1460: null;
1461: WHEN OKC_REMOVE_MSG THEN
1462: l_dq_options.dequeue_mode := dbms_aq.REMOVE_NODATA;

Line 1483: okc_debug.Log('3000: Leaving ',2);

1479: p_msg_count => l_msg_count,
1480: p_msg_data => l_msg_data
1481: );
1482: IF (l_debug = 'Y') THEN
1483: okc_debug.Log('3000: Leaving ',2);
1484: okc_debug.Reset_Indentation;
1485: END IF;
1486:
1487: WHEN OTHERS THEN

Line 1484: okc_debug.Reset_Indentation;

1480: p_msg_data => l_msg_data
1481: );
1482: IF (l_debug = 'Y') THEN
1483: okc_debug.Log('3000: Leaving ',2);
1484: okc_debug.Reset_Indentation;
1485: END IF;
1486:
1487: WHEN OTHERS THEN
1488: x_return_status := OKC_API.HANDLE_EXCEPTIONS (

Line 1509: okc_debug.Log('4000: Leaving ',2);

1505: p_msg_count => l_msg_count,
1506: p_msg_data => l_msg_data
1507: );
1508: IF (l_debug = 'Y') THEN
1509: okc_debug.Log('4000: Leaving ',2);
1510: okc_debug.Reset_Indentation;
1511: END IF;
1512: END dequeue_outcome;
1513:

Line 1510: okc_debug.Reset_Indentation;

1506: p_msg_data => l_msg_data
1507: );
1508: IF (l_debug = 'Y') THEN
1509: okc_debug.Log('4000: Leaving ',2);
1510: okc_debug.Reset_Indentation;
1511: END IF;
1512: END dequeue_outcome;
1513:
1514: PROCEDURE add_subscriber (

Line 1527: okc_debug.Set_Indentation(l_proc);

1523: --
1524:
1525: BEGIN
1526: IF (l_debug = 'Y') THEN
1527: okc_debug.Set_Indentation(l_proc);
1528: okc_debug.Log('10: Entering ',2);
1529: END IF;
1530:
1531: -- code the sub name by replacing dots with hash

Line 1528: okc_debug.Log('10: Entering ',2);

1524:
1525: BEGIN
1526: IF (l_debug = 'Y') THEN
1527: okc_debug.Set_Indentation(l_proc);
1528: okc_debug.Log('10: Entering ',2);
1529: END IF;
1530:
1531: -- code the sub name by replacing dots with hash
1532: code_dots (p_sub_name, l_sub_name);

Line 1552: okc_debug.Set_Indentation(l_proc);

1548: --
1549:
1550: BEGIN
1551: IF (l_debug = 'Y') THEN
1552: okc_debug.Set_Indentation(l_proc);
1553: okc_debug.Log('10: Entering ',2);
1554: END IF;
1555:
1556: code_dots (p_sub_name, l_sub_name);

Line 1553: okc_debug.Log('10: Entering ',2);

1549:
1550: BEGIN
1551: IF (l_debug = 'Y') THEN
1552: okc_debug.Set_Indentation(l_proc);
1553: okc_debug.Log('10: Entering ',2);
1554: END IF;
1555:
1556: code_dots (p_sub_name, l_sub_name);
1557: l_subscriber := sys.aq$_agent (l_sub_name,null,null);

Line 1561: okc_debug.Log('1000: Leaving ',2);

1557: l_subscriber := sys.aq$_agent (l_sub_name,null,null);
1558: DBMS_AQADM.remove_subscriber ( p_queue_name, l_subscriber);
1559:
1560: IF (l_debug = 'Y') THEN
1561: okc_debug.Log('1000: Leaving ',2);
1562: okc_debug.Reset_Indentation;
1563: END IF;
1564:
1565: END remove_subscriber;

Line 1562: okc_debug.Reset_Indentation;

1558: DBMS_AQADM.remove_subscriber ( p_queue_name, l_subscriber);
1559:
1560: IF (l_debug = 'Y') THEN
1561: okc_debug.Log('1000: Leaving ',2);
1562: okc_debug.Reset_Indentation;
1563: END IF;
1564:
1565: END remove_subscriber;
1566:

Line 1608: okc_debug.Set_Indentation(l_proc);

1604: --
1605: l_queue_name varchar2(25) := g_app_name||'.AQ$_OKC_AQ_EV_TAB_E';
1606: BEGIN
1607: IF (l_debug = 'Y') THEN
1608: okc_debug.Set_Indentation(l_proc);
1609: okc_debug.Log('10: Entering ',2);
1610: END IF;
1611:
1612:

Line 1609: okc_debug.Log('10: Entering ',2);

1605: l_queue_name varchar2(25) := g_app_name||'.AQ$_OKC_AQ_EV_TAB_E';
1606: BEGIN
1607: IF (l_debug = 'Y') THEN
1608: okc_debug.Set_Indentation(l_proc);
1609: okc_debug.Log('10: Entering ',2);
1610: END IF;
1611:
1612:
1613: retcode := 0;

Line 1686: okc_debug.Log('1000: Leaving ',2);

1682: OKC_API.END_ACTIVITY ( x_msg_count
1683: , x_msg_data );
1684:
1685: IF (l_debug = 'Y') THEN
1686: okc_debug.Log('1000: Leaving ',2);
1687: okc_debug.Reset_Indentation;
1688: END IF;
1689:
1690:

Line 1687: okc_debug.Reset_Indentation;

1683: , x_msg_data );
1684:
1685: IF (l_debug = 'Y') THEN
1686: okc_debug.Log('1000: Leaving ',2);
1687: okc_debug.Reset_Indentation;
1688: END IF;
1689:
1690:
1691: EXCEPTION

Line 1695: okc_debug.Log('2000: Leaving ',2);

1691: EXCEPTION
1692:
1693: WHEN e_dequeue_timeout THEN
1694: IF (l_debug = 'Y') THEN
1695: okc_debug.Log('2000: Leaving ',2);
1696: okc_debug.Reset_Indentation;
1697: END IF;
1698: null;
1699:

Line 1696: okc_debug.Reset_Indentation;

1692:
1693: WHEN e_dequeue_timeout THEN
1694: IF (l_debug = 'Y') THEN
1695: okc_debug.Log('2000: Leaving ',2);
1696: okc_debug.Reset_Indentation;
1697: END IF;
1698: null;
1699:
1700: WHEN OTHERS THEN

Line 1712: okc_debug.Log('3000: Leaving ',2);

1708: , x_msg_data
1709: , '_PVT'
1710: );
1711: IF (l_debug = 'Y') THEN
1712: okc_debug.Log('3000: Leaving ',2);
1713: okc_debug.Reset_Indentation;
1714: END IF;
1715: END dequeue_exception;
1716:

Line 1713: okc_debug.Reset_Indentation;

1709: , '_PVT'
1710: );
1711: IF (l_debug = 'Y') THEN
1712: okc_debug.Log('3000: Leaving ',2);
1713: okc_debug.Reset_Indentation;
1714: END IF;
1715: END dequeue_exception;
1716:
1717: -- This procedure removes any message from events,outcome or

Line 1765: okc_debug.Set_Indentation(l_proc);

1761: --
1762:
1763: BEGIN
1764: IF (l_debug = 'Y') THEN
1765: okc_debug.Set_Indentation(l_proc);
1766: okc_debug.Log('10: Entering ',2);
1767: END IF;
1768:
1769:

Line 1766: okc_debug.Log('10: Entering ',2);

1762:
1763: BEGIN
1764: IF (l_debug = 'Y') THEN
1765: okc_debug.Set_Indentation(l_proc);
1766: okc_debug.Log('10: Entering ',2);
1767: END IF;
1768:
1769:
1770: retcode := 0;

Line 1825: okc_debug.Log('1000: Leaving ',2);

1821: OKC_API.END_ACTIVITY ( x_msg_count
1822: , x_msg_data );
1823:
1824: IF (l_debug = 'Y') THEN
1825: okc_debug.Log('1000: Leaving ',2);
1826: okc_debug.Reset_Indentation;
1827: END IF;
1828:
1829:

Line 1826: okc_debug.Reset_Indentation;

1822: , x_msg_data );
1823:
1824: IF (l_debug = 'Y') THEN
1825: okc_debug.Log('1000: Leaving ',2);
1826: okc_debug.Reset_Indentation;
1827: END IF;
1828:
1829:
1830: EXCEPTION

Line 1834: okc_debug.Log('2000: Leaving ',2);

1830: EXCEPTION
1831:
1832: WHEN e_dequeue_timeout THEN
1833: IF (l_debug = 'Y') THEN
1834: okc_debug.Log('2000: Leaving ',2);
1835: okc_debug.Reset_Indentation;
1836: END IF;
1837: -- null;
1838:

Line 1835: okc_debug.Reset_Indentation;

1831:
1832: WHEN e_dequeue_timeout THEN
1833: IF (l_debug = 'Y') THEN
1834: okc_debug.Log('2000: Leaving ',2);
1835: okc_debug.Reset_Indentation;
1836: END IF;
1837: -- null;
1838:
1839: WHEN OTHERS THEN

Line 1851: okc_debug.Log('3000: Leaving ',2);

1847: , x_msg_data
1848: , '_PVT'
1849: );
1850: IF (l_debug = 'Y') THEN
1851: okc_debug.Log('3000: Leaving ',2);
1852: okc_debug.Reset_Indentation;
1853: END IF;
1854: END remove_message;
1855:

Line 1852: okc_debug.Reset_Indentation;

1848: , '_PVT'
1849: );
1850: IF (l_debug = 'Y') THEN
1851: okc_debug.Log('3000: Leaving ',2);
1852: okc_debug.Reset_Indentation;
1853: END IF;
1854: END remove_message;
1855:
1856:

Line 1908: okc_debug.Set_Indentation(l_proc);

1904: --
1905:
1906: BEGIN
1907: IF (l_debug = 'Y') THEN
1908: okc_debug.Set_Indentation(l_proc);
1909: okc_debug.Log('10: Entering ',2);
1910: END IF;
1911:
1912:

Line 1909: okc_debug.Log('10: Entering ',2);

1905:
1906: BEGIN
1907: IF (l_debug = 'Y') THEN
1908: okc_debug.Set_Indentation(l_proc);
1909: okc_debug.Log('10: Entering ',2);
1910: END IF;
1911:
1912:
1913: retcode := 0;

Line 1970: okc_debug.Log('1000: Leaving ',2);

1966: OKC_API.END_ACTIVITY ( x_msg_count
1967: , x_msg_data );
1968:
1969: IF (l_debug = 'Y') THEN
1970: okc_debug.Log('1000: Leaving ',2);
1971: okc_debug.Reset_Indentation;
1972: END IF;
1973:
1974:

Line 1971: okc_debug.Reset_Indentation;

1967: , x_msg_data );
1968:
1969: IF (l_debug = 'Y') THEN
1970: okc_debug.Log('1000: Leaving ',2);
1971: okc_debug.Reset_Indentation;
1972: END IF;
1973:
1974:
1975: EXCEPTION

Line 1979: okc_debug.Log('2000: Leaving ',2);

1975: EXCEPTION
1976:
1977: WHEN e_dequeue_timeout THEN
1978: IF (l_debug = 'Y') THEN
1979: okc_debug.Log('2000: Leaving ',2);
1980: okc_debug.Reset_Indentation;
1981: END IF;
1982: null;
1983:

Line 1980: okc_debug.Reset_Indentation;

1976:
1977: WHEN e_dequeue_timeout THEN
1978: IF (l_debug = 'Y') THEN
1979: okc_debug.Log('2000: Leaving ',2);
1980: okc_debug.Reset_Indentation;
1981: END IF;
1982: null;
1983:
1984: WHEN OTHERS THEN

Line 1996: okc_debug.Log('3000: Leaving ',2);

1992: , x_msg_data
1993: , '_PVT'
1994: );
1995: IF (l_debug = 'Y') THEN
1996: okc_debug.Log('3000: Leaving ',2);
1997: okc_debug.Reset_Indentation;
1998: END IF;
1999: END clear_message;
2000:

Line 1997: okc_debug.Reset_Indentation;

1993: , '_PVT'
1994: );
1995: IF (l_debug = 'Y') THEN
1996: okc_debug.Log('3000: Leaving ',2);
1997: okc_debug.Reset_Indentation;
1998: END IF;
1999: END clear_message;
2000:
2001: -- This procedure will be executed by ICM at the time of database shutdown

Line 2020: okc_debug.Set_Indentation(l_proc);

2016: --
2017:
2018: BEGIN
2019: IF (l_debug = 'Y') THEN
2020: okc_debug.Set_Indentation(l_proc);
2021: okc_debug.Log('10: Entering ',2);
2022: END IF;
2023:
2024: --Initialize return status

Line 2021: okc_debug.Log('10: Entering ',2);

2017:
2018: BEGIN
2019: IF (l_debug = 'Y') THEN
2020: okc_debug.Set_Indentation(l_proc);
2021: okc_debug.Log('10: Entering ',2);
2022: END IF;
2023:
2024: --Initialize return status
2025: l_return_status := OKC_API.G_RET_STS_SUCCESS;

Line 2048: okc_debug.Log('1000: Leaving ',2);

2044: , p_queue_name => okc_aq_pvt.g_outcome_queue_name );
2045: commit;
2046:
2047: IF (l_debug = 'Y') THEN
2048: okc_debug.Log('1000: Leaving ',2);
2049: okc_debug.Reset_Indentation;
2050: END IF;
2051:
2052:

Line 2049: okc_debug.Reset_Indentation;

2045: commit;
2046:
2047: IF (l_debug = 'Y') THEN
2048: okc_debug.Log('1000: Leaving ',2);
2049: okc_debug.Reset_Indentation;
2050: END IF;
2051:
2052:
2053: EXCEPTION

Line 2056: okc_debug.Log('2000: Leaving ',2);

2052:
2053: EXCEPTION
2054: WHEN others THEN
2055: IF (l_debug = 'Y') THEN
2056: okc_debug.Log('2000: Leaving ',2);
2057: okc_debug.Reset_Indentation;
2058: END IF;
2059: rollback;
2060: END stop_listener;

Line 2057: okc_debug.Reset_Indentation;

2053: EXCEPTION
2054: WHEN others THEN
2055: IF (l_debug = 'Y') THEN
2056: okc_debug.Log('2000: Leaving ',2);
2057: okc_debug.Reset_Indentation;
2058: END IF;
2059: rollback;
2060: END stop_listener;
2061: