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

APPS.OKC_RULE_PUB dependencies on OKC_API

Line 109: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;

105: p_rulv_rec IN rulv_rec_type,
106: x_rulv_rec OUT NOCOPY rulv_rec_type,
107: p_euro_conv_yn IN VARCHAR2) IS
108:
109: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
110: l_api_name CONSTANT VARCHAR2(30) := 'create_rule';
111: l_rulv_rec rulv_rec_type := p_rulv_rec;
112: l_clob clob;
113: --

Line 122: l_return_status := OKC_API.START_ACTIVITY(l_api_name,

118:
119:
120:
121:
122: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
123: p_init_msg_list,
124: '_PUB',
125: x_return_status);
126: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

Line 126: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

122: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
123: p_init_msg_list,
124: '_PUB',
125: x_return_status);
126: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
127: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
128: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
129: raise OKC_API.G_EXCEPTION_ERROR;
130: END IF;

Line 127: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

123: p_init_msg_list,
124: '_PUB',
125: x_return_status);
126: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
127: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
128: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
129: raise OKC_API.G_EXCEPTION_ERROR;
130: END IF;
131:

Line 128: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN

124: '_PUB',
125: x_return_status);
126: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
127: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
128: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
129: raise OKC_API.G_EXCEPTION_ERROR;
130: END IF;
131:
132: -- Call user hook for BEFORE

Line 129: raise OKC_API.G_EXCEPTION_ERROR;

125: x_return_status);
126: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
127: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
128: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
129: raise OKC_API.G_EXCEPTION_ERROR;
130: END IF;
131:
132: -- Call user hook for BEFORE
133: g_rulv_rec := p_rulv_rec;

Line 149: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

145: DBMS_LOB.freetemporary(l_clob);
146: END IF;
147: */
148: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
149: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
150: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
151: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
152: raise OKC_API.G_EXCEPTION_ERROR;
153: END IF;

Line 150: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

146: END IF;
147: */
148: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
149: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
150: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
151: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
152: raise OKC_API.G_EXCEPTION_ERROR;
153: END IF;
154: l_rulv_rec := migrate_rulv(l_rulv_rec, g_rulv_rec);

Line 151: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN

147: */
148: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
149: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
150: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
151: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
152: raise OKC_API.G_EXCEPTION_ERROR;
153: END IF;
154: l_rulv_rec := migrate_rulv(l_rulv_rec, g_rulv_rec);
155:

Line 152: raise OKC_API.G_EXCEPTION_ERROR;

148: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
149: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
150: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
151: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
152: raise OKC_API.G_EXCEPTION_ERROR;
153: END IF;
154: l_rulv_rec := migrate_rulv(l_rulv_rec, g_rulv_rec);
155:
156: OKC_RULE_PVT.create_rule(

Line 166: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

162: p_rulv_rec => l_rulv_rec,
163: x_rulv_rec => x_rulv_rec,
164: p_euro_conv_yn => p_euro_conv_yn);
165:
166: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
167: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
168: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
169: raise OKC_API.G_EXCEPTION_ERROR;
170: END IF;

Line 167: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

163: x_rulv_rec => x_rulv_rec,
164: p_euro_conv_yn => p_euro_conv_yn);
165:
166: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
167: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
168: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
169: raise OKC_API.G_EXCEPTION_ERROR;
170: END IF;
171:

Line 168: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN

164: p_euro_conv_yn => p_euro_conv_yn);
165:
166: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
167: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
168: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
169: raise OKC_API.G_EXCEPTION_ERROR;
170: END IF;
171:
172: -- Call user hook for AFTER

Line 169: raise OKC_API.G_EXCEPTION_ERROR;

165:
166: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
167: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
168: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
169: raise OKC_API.G_EXCEPTION_ERROR;
170: END IF;
171:
172: -- Call user hook for AFTER
173: g_rulv_rec := x_rulv_rec;

Line 175: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

171:
172: -- Call user hook for AFTER
173: g_rulv_rec := x_rulv_rec;
174: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
175: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
176: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
177: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
178: raise OKC_API.G_EXCEPTION_ERROR;
179: END IF;

Line 176: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

172: -- Call user hook for AFTER
173: g_rulv_rec := x_rulv_rec;
174: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
175: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
176: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
177: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
178: raise OKC_API.G_EXCEPTION_ERROR;
179: END IF;
180: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

Line 177: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN

173: g_rulv_rec := x_rulv_rec;
174: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
175: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
176: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
177: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
178: raise OKC_API.G_EXCEPTION_ERROR;
179: END IF;
180: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
181:

Line 178: raise OKC_API.G_EXCEPTION_ERROR;

174: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
175: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
176: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
177: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
178: raise OKC_API.G_EXCEPTION_ERROR;
179: END IF;
180: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
181:
182:

Line 180: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

176: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
177: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
178: raise OKC_API.G_EXCEPTION_ERROR;
179: END IF;
180: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
181:
182:
183:
184:

Line 186: WHEN OKC_API.G_EXCEPTION_ERROR THEN

182:
183:
184:
185: EXCEPTION
186: WHEN OKC_API.G_EXCEPTION_ERROR THEN
187: x_return_status := OKC_API.HANDLE_EXCEPTIONS
188: (l_api_name
189: ,G_PKG_NAME
190: ,'OKC_API.G_RET_STS_ERROR'

Line 187: x_return_status := OKC_API.HANDLE_EXCEPTIONS

183:
184:
185: EXCEPTION
186: WHEN OKC_API.G_EXCEPTION_ERROR THEN
187: x_return_status := OKC_API.HANDLE_EXCEPTIONS
188: (l_api_name
189: ,G_PKG_NAME
190: ,'OKC_API.G_RET_STS_ERROR'
191: ,x_msg_count

Line 190: ,'OKC_API.G_RET_STS_ERROR'

186: WHEN OKC_API.G_EXCEPTION_ERROR THEN
187: x_return_status := OKC_API.HANDLE_EXCEPTIONS
188: (l_api_name
189: ,G_PKG_NAME
190: ,'OKC_API.G_RET_STS_ERROR'
191: ,x_msg_count
192: ,x_msg_data
193: ,'_PUB');
194:

Line 198: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

194:
195:
196:
197:
198: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
199: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
200: (l_api_name
201: ,G_PKG_NAME
202: ,'OKC_API.G_RET_STS_UNEXP_ERROR'

Line 199: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

195:
196:
197:
198: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
199: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
200: (l_api_name
201: ,G_PKG_NAME
202: ,'OKC_API.G_RET_STS_UNEXP_ERROR'
203: ,x_msg_count

Line 202: ,'OKC_API.G_RET_STS_UNEXP_ERROR'

198: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
199: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
200: (l_api_name
201: ,G_PKG_NAME
202: ,'OKC_API.G_RET_STS_UNEXP_ERROR'
203: ,x_msg_count
204: ,x_msg_data
205: ,'_PUB');
206:

Line 211: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

207:
208:
209:
210: WHEN OTHERS THEN
211: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
212: (l_api_name
213: ,G_PKG_NAME
214: ,'OTHERS'
215: ,x_msg_count

Line 269: OKC_API.SET_MESSAGE(

265:
266: NULL;
267: WHEN OTHERS THEN
268: -- store SQL error message on message stack
269: OKC_API.SET_MESSAGE(
270: p_app_name => G_APP_NAME,
271: p_msg_name => G_UNEXPECTED_ERROR,
272: p_token1 => G_SQLCODE_TOKEN,
273: p_token1_value => SQLCODE,

Line 277: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

273: p_token1_value => SQLCODE,
274: p_token2 => G_SQLERRM_TOKEN,
275: p_token2_value => SQLERRM);
276: -- notify caller of an error as UNEXPETED error
277: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
278:
279:
280:
281:

Line 296: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;

292: x_msg_data OUT NOCOPY VARCHAR2,
293: p_rulv_tbl IN rulv_tbl_type,
294: x_rulv_tbl OUT NOCOPY rulv_tbl_type) IS
295: i NUMBER := 0;
296: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
297: --
298: l_proc varchar2(72) := g_package||'create_rule';
299: --
300:

Line 306: x_return_status := OKC_API.G_RET_STS_SUCCESS;

302:
303:
304:
305:
306: x_return_status := OKC_API.G_RET_STS_SUCCESS;
307: IF p_rulv_tbl.COUNT > 0 THEN
308: i := p_rulv_tbl.FIRST;
309: LOOP
310: create_rule(

Line 319: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN

315: x_msg_data => x_msg_data,
316: p_rulv_rec => p_rulv_tbl(i),
317: x_rulv_rec => x_rulv_tbl(i),
318: p_euro_conv_yn => 'N');
319: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
320: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
321: x_return_status := l_return_status;
322: raise G_EXCEPTION_HALT_VALIDATION;
323: ELSE

Line 320: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

316: p_rulv_rec => p_rulv_tbl(i),
317: x_rulv_rec => x_rulv_tbl(i),
318: p_euro_conv_yn => 'N');
319: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
320: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
321: x_return_status := l_return_status;
322: raise G_EXCEPTION_HALT_VALIDATION;
323: ELSE
324: x_return_status := l_return_status;

Line 344: OKC_API.SET_MESSAGE(

340:
341: NULL;
342: WHEN OTHERS THEN
343: -- store SQL error message on message stack
344: OKC_API.SET_MESSAGE(
345: p_app_name => G_APP_NAME,
346: p_msg_name => G_UNEXPECTED_ERROR,
347: p_token1 => G_SQLCODE_TOKEN,
348: p_token1_value => SQLCODE,

Line 352: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

348: p_token1_value => SQLCODE,
349: p_token2 => G_SQLERRM_TOKEN,
350: p_token2_value => SQLERRM);
351: -- notify caller of an error as UNEXPETED error
352: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
353:
354:
355:
356:

Line 373: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;

369: x_rulv_tbl OUT NOCOPY rulv_tbl_type,
370: p_euro_conv_yn IN VARCHAR2)
371: IS
372: i NUMBER := 0;
373: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
374: --
375: l_proc varchar2(72) := g_package||'create_rule';
376: --
377:

Line 383: x_return_status := OKC_API.G_RET_STS_SUCCESS;

379:
380:
381:
382:
383: x_return_status := OKC_API.G_RET_STS_SUCCESS;
384: IF p_rulv_tbl.COUNT > 0 THEN
385: i := p_rulv_tbl.FIRST;
386: LOOP
387: create_rule(

Line 396: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN

392: x_msg_data => x_msg_data,
393: p_rulv_rec => p_rulv_tbl(i),
394: x_rulv_rec => x_rulv_tbl(i),
395: p_euro_conv_yn => p_euro_conv_yn);
396: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
397: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
398: x_return_status := l_return_status;
399: raise G_EXCEPTION_HALT_VALIDATION;
400: ELSE

Line 397: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

393: p_rulv_rec => p_rulv_tbl(i),
394: x_rulv_rec => x_rulv_tbl(i),
395: p_euro_conv_yn => p_euro_conv_yn);
396: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
397: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
398: x_return_status := l_return_status;
399: raise G_EXCEPTION_HALT_VALIDATION;
400: ELSE
401: x_return_status := l_return_status;

Line 421: OKC_API.SET_MESSAGE(

417:
418: NULL;
419: WHEN OTHERS THEN
420: -- store SQL error message on message stack
421: OKC_API.SET_MESSAGE(
422: p_app_name => G_APP_NAME,
423: p_msg_name => G_UNEXPECTED_ERROR,
424: p_token1 => G_SQLCODE_TOKEN,
425: p_token1_value => SQLCODE,

Line 429: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

425: p_token1_value => SQLCODE,
426: p_token2 => G_SQLERRM_TOKEN,
427: p_token2_value => SQLERRM);
428: -- notify caller of an error as UNEXPETED error
429: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
430:
431:
432:
433:

Line 447: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;

443: x_msg_count OUT NOCOPY NUMBER,
444: x_msg_data OUT NOCOPY VARCHAR2,
445: p_rulv_rec IN rulv_rec_type,
446: x_rulv_rec OUT NOCOPY rulv_rec_type) IS
447: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
448: l_api_name CONSTANT VARCHAR2(30) := 'update_rule';
449: l_rulv_rec rulv_rec_type := p_rulv_rec;
450: l_clob clob;
451: --

Line 460: l_return_status := OKC_API.START_ACTIVITY(l_api_name,

456:
457:
458:
459:
460: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
461: p_init_msg_list,
462: '_PUB',
463: x_return_status);
464: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

Line 464: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

460: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
461: p_init_msg_list,
462: '_PUB',
463: x_return_status);
464: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
465: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
466: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
467: raise OKC_API.G_EXCEPTION_ERROR;
468: END IF;

Line 465: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

461: p_init_msg_list,
462: '_PUB',
463: x_return_status);
464: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
465: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
466: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
467: raise OKC_API.G_EXCEPTION_ERROR;
468: END IF;
469:

Line 466: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN

462: '_PUB',
463: x_return_status);
464: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
465: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
466: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
467: raise OKC_API.G_EXCEPTION_ERROR;
468: END IF;
469:
470: -- Call user hook for BEFORE

Line 467: raise OKC_API.G_EXCEPTION_ERROR;

463: x_return_status);
464: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
465: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
466: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
467: raise OKC_API.G_EXCEPTION_ERROR;
468: END IF;
469:
470: -- Call user hook for BEFORE
471: g_rulv_rec := p_rulv_rec;

Line 486: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

482: DBMS_LOB.freetemporary(l_clob);
483: END IF;
484: */
485: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
486: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
487: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
488: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
489: raise OKC_API.G_EXCEPTION_ERROR;
490: END IF;

Line 487: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

483: END IF;
484: */
485: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
486: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
487: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
488: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
489: raise OKC_API.G_EXCEPTION_ERROR;
490: END IF;
491: l_rulv_rec := migrate_rulv(l_rulv_rec, g_rulv_rec);

Line 488: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN

484: */
485: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
486: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
487: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
488: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
489: raise OKC_API.G_EXCEPTION_ERROR;
490: END IF;
491: l_rulv_rec := migrate_rulv(l_rulv_rec, g_rulv_rec);
492:

Line 489: raise OKC_API.G_EXCEPTION_ERROR;

485: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
486: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
487: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
488: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
489: raise OKC_API.G_EXCEPTION_ERROR;
490: END IF;
491: l_rulv_rec := migrate_rulv(l_rulv_rec, g_rulv_rec);
492:
493: OKC_RULE_PVT.update_rule(

Line 502: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

498: x_msg_data => x_msg_data,
499: p_rulv_rec => l_rulv_rec,
500: x_rulv_rec => x_rulv_rec);
501:
502: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
503: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
504: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
505: raise OKC_API.G_EXCEPTION_ERROR;
506: END IF;

Line 503: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

499: p_rulv_rec => l_rulv_rec,
500: x_rulv_rec => x_rulv_rec);
501:
502: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
503: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
504: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
505: raise OKC_API.G_EXCEPTION_ERROR;
506: END IF;
507:

Line 504: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN

500: x_rulv_rec => x_rulv_rec);
501:
502: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
503: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
504: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
505: raise OKC_API.G_EXCEPTION_ERROR;
506: END IF;
507:
508: -- Call user hook for AFTER

Line 505: raise OKC_API.G_EXCEPTION_ERROR;

501:
502: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
503: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
504: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
505: raise OKC_API.G_EXCEPTION_ERROR;
506: END IF;
507:
508: -- Call user hook for AFTER
509: g_rulv_rec := x_rulv_rec;

Line 511: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

507:
508: -- Call user hook for AFTER
509: g_rulv_rec := x_rulv_rec;
510: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
511: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
512: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
513: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
514: raise OKC_API.G_EXCEPTION_ERROR;
515: END IF;

Line 512: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

508: -- Call user hook for AFTER
509: g_rulv_rec := x_rulv_rec;
510: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
511: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
512: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
513: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
514: raise OKC_API.G_EXCEPTION_ERROR;
515: END IF;
516: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

Line 513: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN

509: g_rulv_rec := x_rulv_rec;
510: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
511: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
512: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
513: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
514: raise OKC_API.G_EXCEPTION_ERROR;
515: END IF;
516: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
517:

Line 514: raise OKC_API.G_EXCEPTION_ERROR;

510: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
511: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
512: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
513: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
514: raise OKC_API.G_EXCEPTION_ERROR;
515: END IF;
516: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
517:
518:

Line 516: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

512: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
513: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
514: raise OKC_API.G_EXCEPTION_ERROR;
515: END IF;
516: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
517:
518:
519:
520:

Line 522: WHEN OKC_API.G_EXCEPTION_ERROR THEN

518:
519:
520:
521: EXCEPTION
522: WHEN OKC_API.G_EXCEPTION_ERROR THEN
523: x_return_status := OKC_API.HANDLE_EXCEPTIONS
524: (l_api_name
525: ,G_PKG_NAME
526: ,'OKC_API.G_RET_STS_ERROR'

Line 523: x_return_status := OKC_API.HANDLE_EXCEPTIONS

519:
520:
521: EXCEPTION
522: WHEN OKC_API.G_EXCEPTION_ERROR THEN
523: x_return_status := OKC_API.HANDLE_EXCEPTIONS
524: (l_api_name
525: ,G_PKG_NAME
526: ,'OKC_API.G_RET_STS_ERROR'
527: ,x_msg_count

Line 526: ,'OKC_API.G_RET_STS_ERROR'

522: WHEN OKC_API.G_EXCEPTION_ERROR THEN
523: x_return_status := OKC_API.HANDLE_EXCEPTIONS
524: (l_api_name
525: ,G_PKG_NAME
526: ,'OKC_API.G_RET_STS_ERROR'
527: ,x_msg_count
528: ,x_msg_data
529: ,'_PUB');
530:

Line 534: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

530:
531:
532:
533:
534: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
535: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
536: (l_api_name
537: ,G_PKG_NAME
538: ,'OKC_API.G_RET_STS_UNEXP_ERROR'

Line 535: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

531:
532:
533:
534: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
535: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
536: (l_api_name
537: ,G_PKG_NAME
538: ,'OKC_API.G_RET_STS_UNEXP_ERROR'
539: ,x_msg_count

Line 538: ,'OKC_API.G_RET_STS_UNEXP_ERROR'

534: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
535: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
536: (l_api_name
537: ,G_PKG_NAME
538: ,'OKC_API.G_RET_STS_UNEXP_ERROR'
539: ,x_msg_count
540: ,x_msg_data
541: ,'_PUB');
542:

Line 547: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

543:
544:
545:
546: WHEN OTHERS THEN
547: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
548: (l_api_name
549: ,G_PKG_NAME
550: ,'OTHERS'
551: ,x_msg_count

Line 572: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;

568: x_msg_data OUT NOCOPY VARCHAR2,
569: p_rulv_tbl IN rulv_tbl_type,
570: x_rulv_tbl OUT NOCOPY rulv_tbl_type) IS
571: i NUMBER := 0;
572: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
573: --
574: l_proc varchar2(72) := g_package||'update_rule';
575: --
576:

Line 582: x_return_status := OKC_API.G_RET_STS_SUCCESS;

578:
579:
580:
581:
582: x_return_status := OKC_API.G_RET_STS_SUCCESS;
583: IF p_rulv_tbl.COUNT > 0 THEN
584: i := p_rulv_tbl.FIRST;
585: LOOP
586: update_rule(

Line 594: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN

590: x_msg_count => x_msg_count,
591: x_msg_data => x_msg_data,
592: p_rulv_rec => p_rulv_tbl(i),
593: x_rulv_rec => x_rulv_tbl(i));
594: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
595: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
596: x_return_status := l_return_status;
597: raise G_EXCEPTION_HALT_VALIDATION;
598: ELSE

Line 595: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

591: x_msg_data => x_msg_data,
592: p_rulv_rec => p_rulv_tbl(i),
593: x_rulv_rec => x_rulv_tbl(i));
594: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
595: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
596: x_return_status := l_return_status;
597: raise G_EXCEPTION_HALT_VALIDATION;
598: ELSE
599: x_return_status := l_return_status;

Line 619: OKC_API.SET_MESSAGE(

615:
616: NULL;
617: WHEN OTHERS THEN
618: -- store SQL error message on message stack
619: OKC_API.SET_MESSAGE(
620: p_app_name => G_APP_NAME,
621: p_msg_name => G_UNEXPECTED_ERROR,
622: p_token1 => G_SQLCODE_TOKEN,
623: p_token1_value => SQLCODE,

Line 627: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

623: p_token1_value => SQLCODE,
624: p_token2 => G_SQLERRM_TOKEN,
625: p_token2_value => SQLERRM);
626: -- notify caller of an error as UNEXPETED error
627: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
628:
629:
630:
631:

Line 644: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;

640: x_return_status OUT NOCOPY VARCHAR2,
641: x_msg_count OUT NOCOPY NUMBER,
642: x_msg_data OUT NOCOPY VARCHAR2,
643: p_rulv_rec IN rulv_rec_type) IS
644: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
645: l_api_name CONSTANT VARCHAR2(30) := 'validate_rule';
646: l_rulv_rec rulv_rec_type := p_rulv_rec;
647: --
648: l_proc varchar2(72) := g_package||'validate_rule';

Line 656: l_return_status := OKC_API.START_ACTIVITY(l_api_name,

652:
653:
654:
655:
656: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
657: p_init_msg_list,
658: '_PUB',
659: x_return_status);
660: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

Line 660: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

656: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
657: p_init_msg_list,
658: '_PUB',
659: x_return_status);
660: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
661: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
662: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
663: raise OKC_API.G_EXCEPTION_ERROR;
664: END IF;

Line 661: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

657: p_init_msg_list,
658: '_PUB',
659: x_return_status);
660: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
661: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
662: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
663: raise OKC_API.G_EXCEPTION_ERROR;
664: END IF;
665: -- Call user hook for BEFORE

Line 662: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN

658: '_PUB',
659: x_return_status);
660: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
661: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
662: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
663: raise OKC_API.G_EXCEPTION_ERROR;
664: END IF;
665: -- Call user hook for BEFORE
666: g_rulv_rec := p_rulv_rec;

Line 663: raise OKC_API.G_EXCEPTION_ERROR;

659: x_return_status);
660: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
661: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
662: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
663: raise OKC_API.G_EXCEPTION_ERROR;
664: END IF;
665: -- Call user hook for BEFORE
666: g_rulv_rec := p_rulv_rec;
667: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');

Line 668: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

664: END IF;
665: -- Call user hook for BEFORE
666: g_rulv_rec := p_rulv_rec;
667: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
668: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
669: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
670: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
671: raise OKC_API.G_EXCEPTION_ERROR;
672: END IF;

Line 669: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

665: -- Call user hook for BEFORE
666: g_rulv_rec := p_rulv_rec;
667: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
668: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
669: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
670: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
671: raise OKC_API.G_EXCEPTION_ERROR;
672: END IF;
673: l_rulv_rec := migrate_rulv(l_rulv_rec, g_rulv_rec);

Line 670: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN

666: g_rulv_rec := p_rulv_rec;
667: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
668: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
669: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
670: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
671: raise OKC_API.G_EXCEPTION_ERROR;
672: END IF;
673: l_rulv_rec := migrate_rulv(l_rulv_rec, g_rulv_rec);
674:

Line 671: raise OKC_API.G_EXCEPTION_ERROR;

667: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
668: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
669: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
670: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
671: raise OKC_API.G_EXCEPTION_ERROR;
672: END IF;
673: l_rulv_rec := migrate_rulv(l_rulv_rec, g_rulv_rec);
674:
675: OKC_RULE_PVT.validate_rule(

Line 683: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

679: x_msg_count => x_msg_count,
680: x_msg_data => x_msg_data,
681: p_rulv_rec => l_rulv_rec);
682:
683: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
684: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
685: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
686: raise OKC_API.G_EXCEPTION_ERROR;
687: END IF;

Line 684: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

680: x_msg_data => x_msg_data,
681: p_rulv_rec => l_rulv_rec);
682:
683: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
684: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
685: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
686: raise OKC_API.G_EXCEPTION_ERROR;
687: END IF;
688:

Line 685: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN

681: p_rulv_rec => l_rulv_rec);
682:
683: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
684: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
685: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
686: raise OKC_API.G_EXCEPTION_ERROR;
687: END IF;
688:
689: -- Call user hook for AFTER

Line 686: raise OKC_API.G_EXCEPTION_ERROR;

682:
683: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
684: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
685: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
686: raise OKC_API.G_EXCEPTION_ERROR;
687: END IF;
688:
689: -- Call user hook for AFTER
690: g_rulv_rec := l_rulv_rec;

Line 692: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

688:
689: -- Call user hook for AFTER
690: g_rulv_rec := l_rulv_rec;
691: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
692: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
693: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
694: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
695: raise OKC_API.G_EXCEPTION_ERROR;
696: END IF;

Line 693: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

689: -- Call user hook for AFTER
690: g_rulv_rec := l_rulv_rec;
691: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
692: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
693: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
694: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
695: raise OKC_API.G_EXCEPTION_ERROR;
696: END IF;
697: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

Line 694: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN

690: g_rulv_rec := l_rulv_rec;
691: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
692: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
693: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
694: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
695: raise OKC_API.G_EXCEPTION_ERROR;
696: END IF;
697: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
698:

Line 695: raise OKC_API.G_EXCEPTION_ERROR;

691: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
692: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
693: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
694: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
695: raise OKC_API.G_EXCEPTION_ERROR;
696: END IF;
697: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
698:
699:

Line 697: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

693: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
694: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
695: raise OKC_API.G_EXCEPTION_ERROR;
696: END IF;
697: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
698:
699:
700:
701:

Line 703: WHEN OKC_API.G_EXCEPTION_ERROR THEN

699:
700:
701:
702: EXCEPTION
703: WHEN OKC_API.G_EXCEPTION_ERROR THEN
704: x_return_status := OKC_API.HANDLE_EXCEPTIONS
705: (l_api_name
706: ,G_PKG_NAME
707: ,'OKC_API.G_RET_STS_ERROR'

Line 704: x_return_status := OKC_API.HANDLE_EXCEPTIONS

700:
701:
702: EXCEPTION
703: WHEN OKC_API.G_EXCEPTION_ERROR THEN
704: x_return_status := OKC_API.HANDLE_EXCEPTIONS
705: (l_api_name
706: ,G_PKG_NAME
707: ,'OKC_API.G_RET_STS_ERROR'
708: ,x_msg_count

Line 707: ,'OKC_API.G_RET_STS_ERROR'

703: WHEN OKC_API.G_EXCEPTION_ERROR THEN
704: x_return_status := OKC_API.HANDLE_EXCEPTIONS
705: (l_api_name
706: ,G_PKG_NAME
707: ,'OKC_API.G_RET_STS_ERROR'
708: ,x_msg_count
709: ,x_msg_data
710: ,'_PUB');
711:

Line 715: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

711:
712:
713:
714:
715: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
716: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
717: (l_api_name
718: ,G_PKG_NAME
719: ,'OKC_API.G_RET_STS_UNEXP_ERROR'

Line 716: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

712:
713:
714:
715: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
716: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
717: (l_api_name
718: ,G_PKG_NAME
719: ,'OKC_API.G_RET_STS_UNEXP_ERROR'
720: ,x_msg_count

Line 719: ,'OKC_API.G_RET_STS_UNEXP_ERROR'

715: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
716: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
717: (l_api_name
718: ,G_PKG_NAME
719: ,'OKC_API.G_RET_STS_UNEXP_ERROR'
720: ,x_msg_count
721: ,x_msg_data
722: ,'_PUB');
723:

Line 728: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

724:
725:
726:
727: WHEN OTHERS THEN
728: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
729: (l_api_name
730: ,G_PKG_NAME
731: ,'OTHERS'
732: ,x_msg_count

Line 752: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;

748: x_msg_count OUT NOCOPY NUMBER,
749: x_msg_data OUT NOCOPY VARCHAR2,
750: p_rulv_tbl IN rulv_tbl_type) IS
751: i NUMBER := 0;
752: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
753: --
754: l_proc varchar2(72) := g_package||'validate_rule';
755: --
756:

Line 762: x_return_status := OKC_API.G_RET_STS_SUCCESS;

758:
759:
760:
761:
762: x_return_status := OKC_API.G_RET_STS_SUCCESS;
763: IF p_rulv_tbl.COUNT > 0 THEN
764: i := p_rulv_tbl.FIRST;
765: LOOP
766: validate_rule(

Line 773: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN

769: x_return_status => l_return_status,
770: x_msg_count => x_msg_count,
771: x_msg_data => x_msg_data,
772: p_rulv_rec => p_rulv_tbl(i));
773: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
774: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
775: x_return_status := l_return_status;
776: raise G_EXCEPTION_HALT_VALIDATION;
777: ELSE

Line 774: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

770: x_msg_count => x_msg_count,
771: x_msg_data => x_msg_data,
772: p_rulv_rec => p_rulv_tbl(i));
773: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
774: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
775: x_return_status := l_return_status;
776: raise G_EXCEPTION_HALT_VALIDATION;
777: ELSE
778: x_return_status := l_return_status;

Line 798: OKC_API.SET_MESSAGE(

794:
795: NULL;
796: WHEN OTHERS THEN
797: -- store SQL error message on message stack
798: OKC_API.SET_MESSAGE(
799: p_app_name => G_APP_NAME,
800: p_msg_name => G_UNEXPECTED_ERROR,
801: p_token1 => G_SQLCODE_TOKEN,
802: p_token1_value => SQLCODE,

Line 806: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

802: p_token1_value => SQLCODE,
803: p_token2 => G_SQLERRM_TOKEN,
804: p_token2_value => SQLERRM);
805: -- notify caller of an error as UNEXPETED error
806: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
807:
808:
809:
810:

Line 823: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;

819: x_return_status OUT NOCOPY VARCHAR2,
820: x_msg_count OUT NOCOPY NUMBER,
821: x_msg_data OUT NOCOPY VARCHAR2,
822: p_rulv_rec IN rulv_rec_type) IS
823: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
824: l_api_name CONSTANT VARCHAR2(30) := 'delete_rule';
825: l_rulv_rec rulv_rec_type := p_rulv_rec;
826: --
827: l_proc varchar2(72) := g_package||'delete_rule';

Line 835: l_return_status := OKC_API.START_ACTIVITY(l_api_name,

831:
832:
833:
834:
835: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
836: p_init_msg_list,
837: '_PUB',
838: x_return_status);
839: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

Line 839: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

835: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
836: p_init_msg_list,
837: '_PUB',
838: x_return_status);
839: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
840: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
841: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
842: raise OKC_API.G_EXCEPTION_ERROR;
843: END IF;

Line 840: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

836: p_init_msg_list,
837: '_PUB',
838: x_return_status);
839: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
840: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
841: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
842: raise OKC_API.G_EXCEPTION_ERROR;
843: END IF;
844: -- Call user hook for BEFORE

Line 841: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN

837: '_PUB',
838: x_return_status);
839: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
840: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
841: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
842: raise OKC_API.G_EXCEPTION_ERROR;
843: END IF;
844: -- Call user hook for BEFORE
845: g_rulv_rec := p_rulv_rec;

Line 842: raise OKC_API.G_EXCEPTION_ERROR;

838: x_return_status);
839: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
840: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
841: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
842: raise OKC_API.G_EXCEPTION_ERROR;
843: END IF;
844: -- Call user hook for BEFORE
845: g_rulv_rec := p_rulv_rec;
846: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');

Line 847: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

843: END IF;
844: -- Call user hook for BEFORE
845: g_rulv_rec := p_rulv_rec;
846: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
847: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
848: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
849: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
850: raise OKC_API.G_EXCEPTION_ERROR;
851: END IF;

Line 848: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

844: -- Call user hook for BEFORE
845: g_rulv_rec := p_rulv_rec;
846: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
847: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
848: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
849: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
850: raise OKC_API.G_EXCEPTION_ERROR;
851: END IF;
852:

Line 849: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN

845: g_rulv_rec := p_rulv_rec;
846: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
847: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
848: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
849: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
850: raise OKC_API.G_EXCEPTION_ERROR;
851: END IF;
852:
853: OKC_RULE_PVT.delete_rule(

Line 850: raise OKC_API.G_EXCEPTION_ERROR;

846: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
847: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
848: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
849: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
850: raise OKC_API.G_EXCEPTION_ERROR;
851: END IF;
852:
853: OKC_RULE_PVT.delete_rule(
854: p_api_version => p_api_version,

Line 861: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

857: x_msg_count => x_msg_count,
858: x_msg_data => x_msg_data,
859: p_rulv_rec => p_rulv_rec);
860:
861: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
862: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
863: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
864: raise OKC_API.G_EXCEPTION_ERROR;
865: END IF;

Line 862: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

858: x_msg_data => x_msg_data,
859: p_rulv_rec => p_rulv_rec);
860:
861: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
862: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
863: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
864: raise OKC_API.G_EXCEPTION_ERROR;
865: END IF;
866:

Line 863: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN

859: p_rulv_rec => p_rulv_rec);
860:
861: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
862: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
863: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
864: raise OKC_API.G_EXCEPTION_ERROR;
865: END IF;
866:
867: -- Call user hook for AFTER

Line 864: raise OKC_API.G_EXCEPTION_ERROR;

860:
861: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
862: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
863: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
864: raise OKC_API.G_EXCEPTION_ERROR;
865: END IF;
866:
867: -- Call user hook for AFTER
868: g_rulv_rec := l_rulv_rec;

Line 870: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

866:
867: -- Call user hook for AFTER
868: g_rulv_rec := l_rulv_rec;
869: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
870: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
871: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
872: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
873: raise OKC_API.G_EXCEPTION_ERROR;
874: END IF;

Line 871: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

867: -- Call user hook for AFTER
868: g_rulv_rec := l_rulv_rec;
869: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
870: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
871: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
872: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
873: raise OKC_API.G_EXCEPTION_ERROR;
874: END IF;
875: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

Line 872: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN

868: g_rulv_rec := l_rulv_rec;
869: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
870: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
871: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
872: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
873: raise OKC_API.G_EXCEPTION_ERROR;
874: END IF;
875: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
876:

Line 873: raise OKC_API.G_EXCEPTION_ERROR;

869: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
870: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
871: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
872: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
873: raise OKC_API.G_EXCEPTION_ERROR;
874: END IF;
875: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
876:
877:

Line 875: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

871: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
872: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
873: raise OKC_API.G_EXCEPTION_ERROR;
874: END IF;
875: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
876:
877:
878:
879:

Line 881: WHEN OKC_API.G_EXCEPTION_ERROR THEN

877:
878:
879:
880: EXCEPTION
881: WHEN OKC_API.G_EXCEPTION_ERROR THEN
882: x_return_status := OKC_API.HANDLE_EXCEPTIONS
883: (l_api_name
884: ,G_PKG_NAME
885: ,'OKC_API.G_RET_STS_ERROR'

Line 882: x_return_status := OKC_API.HANDLE_EXCEPTIONS

878:
879:
880: EXCEPTION
881: WHEN OKC_API.G_EXCEPTION_ERROR THEN
882: x_return_status := OKC_API.HANDLE_EXCEPTIONS
883: (l_api_name
884: ,G_PKG_NAME
885: ,'OKC_API.G_RET_STS_ERROR'
886: ,x_msg_count

Line 885: ,'OKC_API.G_RET_STS_ERROR'

881: WHEN OKC_API.G_EXCEPTION_ERROR THEN
882: x_return_status := OKC_API.HANDLE_EXCEPTIONS
883: (l_api_name
884: ,G_PKG_NAME
885: ,'OKC_API.G_RET_STS_ERROR'
886: ,x_msg_count
887: ,x_msg_data
888: ,'_PUB');
889:

Line 893: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

889:
890:
891:
892:
893: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
894: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
895: (l_api_name
896: ,G_PKG_NAME
897: ,'OKC_API.G_RET_STS_UNEXP_ERROR'

Line 894: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

890:
891:
892:
893: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
894: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
895: (l_api_name
896: ,G_PKG_NAME
897: ,'OKC_API.G_RET_STS_UNEXP_ERROR'
898: ,x_msg_count

Line 897: ,'OKC_API.G_RET_STS_UNEXP_ERROR'

893: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
894: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
895: (l_api_name
896: ,G_PKG_NAME
897: ,'OKC_API.G_RET_STS_UNEXP_ERROR'
898: ,x_msg_count
899: ,x_msg_data
900: ,'_PUB');
901:

Line 906: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

902:
903:
904:
905: WHEN OTHERS THEN
906: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
907: (l_api_name
908: ,G_PKG_NAME
909: ,'OTHERS'
910: ,x_msg_count

Line 930: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;

926: x_msg_count OUT NOCOPY NUMBER,
927: x_msg_data OUT NOCOPY VARCHAR2,
928: p_rulv_tbl IN rulv_tbl_type) IS
929: i NUMBER := 0;
930: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
931: --
932: l_proc varchar2(72) := g_package||'delete_rule';
933: --
934:

Line 940: x_return_status := OKC_API.G_RET_STS_SUCCESS;

936:
937:
938:
939:
940: x_return_status := OKC_API.G_RET_STS_SUCCESS;
941: IF p_rulv_tbl.COUNT > 0 THEN
942: i := p_rulv_tbl.FIRST;
943: LOOP
944: delete_rule(

Line 951: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN

947: x_return_status => l_return_status,
948: x_msg_count => x_msg_count,
949: x_msg_data => x_msg_data,
950: p_rulv_rec => p_rulv_tbl(i));
951: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
952: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
953: x_return_status := l_return_status;
954: raise G_EXCEPTION_HALT_VALIDATION;
955: ELSE

Line 952: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

948: x_msg_count => x_msg_count,
949: x_msg_data => x_msg_data,
950: p_rulv_rec => p_rulv_tbl(i));
951: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
952: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
953: x_return_status := l_return_status;
954: raise G_EXCEPTION_HALT_VALIDATION;
955: ELSE
956: x_return_status := l_return_status;

Line 976: OKC_API.SET_MESSAGE(

972:
973: NULL;
974: WHEN OTHERS THEN
975: -- store SQL error message on message stack
976: OKC_API.SET_MESSAGE(
977: p_app_name => G_APP_NAME,
978: p_msg_name => G_UNEXPECTED_ERROR,
979: p_token1 => G_SQLCODE_TOKEN,
980: p_token1_value => SQLCODE,

Line 984: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

980: p_token1_value => SQLCODE,
981: p_token2 => G_SQLERRM_TOKEN,
982: p_token2_value => SQLERRM);
983: -- notify caller of an error as UNEXPETED error
984: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
985:
986:
987:
988:

Line 1034: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;

1030: x_msg_count OUT NOCOPY NUMBER,
1031: x_msg_data OUT NOCOPY VARCHAR2,
1032: p_rulv_tbl IN rulv_tbl_type) IS
1033: i NUMBER := 0;
1034: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1035: --
1036: l_proc varchar2(72) := g_package||'lock_rule';
1037: --
1038:

Line 1044: x_return_status := OKC_API.G_RET_STS_SUCCESS;

1040:
1041:
1042:
1043:
1044: x_return_status := OKC_API.G_RET_STS_SUCCESS;
1045: IF p_rulv_tbl.COUNT > 0 THEN
1046: i := p_rulv_tbl.FIRST;
1047: LOOP
1048: lock_rule(

Line 1055: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN

1051: x_return_status => l_return_status,
1052: x_msg_count => x_msg_count,
1053: x_msg_data => x_msg_data,
1054: p_rulv_rec => p_rulv_tbl(i));
1055: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1056: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1057: x_return_status := l_return_status;
1058: raise G_EXCEPTION_HALT_VALIDATION;
1059: ELSE

Line 1056: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

1052: x_msg_count => x_msg_count,
1053: x_msg_data => x_msg_data,
1054: p_rulv_rec => p_rulv_tbl(i));
1055: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1056: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1057: x_return_status := l_return_status;
1058: raise G_EXCEPTION_HALT_VALIDATION;
1059: ELSE
1060: x_return_status := l_return_status;

Line 1080: OKC_API.SET_MESSAGE(

1076:
1077: NULL;
1078: WHEN OTHERS THEN
1079: -- store SQL error message on message stack
1080: OKC_API.SET_MESSAGE(
1081: p_app_name => G_APP_NAME,
1082: p_msg_name => G_UNEXPECTED_ERROR,
1083: p_token1 => G_SQLCODE_TOKEN,
1084: p_token1_value => SQLCODE,

Line 1088: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

1084: p_token1_value => SQLCODE,
1085: p_token2 => G_SQLERRM_TOKEN,
1086: p_token2_value => SQLERRM);
1087: -- notify caller of an error as UNEXPETED error
1088: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
1089:
1090:
1091:
1092:

Line 1163: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;

1159: x_msg_count OUT NOCOPY NUMBER,
1160: x_msg_data OUT NOCOPY VARCHAR2,
1161: p_rgpv_rec IN rgpv_rec_type,
1162: x_rgpv_rec OUT NOCOPY rgpv_rec_type) IS
1163: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1164: l_api_name CONSTANT VARCHAR2(30) := 'create_rule_group';
1165: l_rgpv_rec rgpv_rec_type := p_rgpv_rec;
1166: --
1167: l_proc varchar2(72) := g_package||'create_rule_group';

Line 1175: l_return_status := OKC_API.START_ACTIVITY(l_api_name,

1171:
1172:
1173:
1174:
1175: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
1176: p_init_msg_list,
1177: '_PUB',
1178: x_return_status);
1179: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

Line 1179: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

1175: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
1176: p_init_msg_list,
1177: '_PUB',
1178: x_return_status);
1179: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1180: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1181: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1182: raise OKC_API.G_EXCEPTION_ERROR;
1183: END IF;

Line 1180: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1176: p_init_msg_list,
1177: '_PUB',
1178: x_return_status);
1179: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1180: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1181: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1182: raise OKC_API.G_EXCEPTION_ERROR;
1183: END IF;
1184: -- Call user hook for BEFORE

Line 1181: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN

1177: '_PUB',
1178: x_return_status);
1179: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1180: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1181: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1182: raise OKC_API.G_EXCEPTION_ERROR;
1183: END IF;
1184: -- Call user hook for BEFORE
1185: g_rgpv_rec := p_rgpv_rec;

Line 1182: raise OKC_API.G_EXCEPTION_ERROR;

1178: x_return_status);
1179: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1180: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1181: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1182: raise OKC_API.G_EXCEPTION_ERROR;
1183: END IF;
1184: -- Call user hook for BEFORE
1185: g_rgpv_rec := p_rgpv_rec;
1186:

Line 1188: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

1184: -- Call user hook for BEFORE
1185: g_rgpv_rec := p_rgpv_rec;
1186:
1187: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
1188: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1189: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1190: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1191: raise OKC_API.G_EXCEPTION_ERROR;
1192: END IF;

Line 1189: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1185: g_rgpv_rec := p_rgpv_rec;
1186:
1187: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
1188: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1189: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1190: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1191: raise OKC_API.G_EXCEPTION_ERROR;
1192: END IF;
1193: l_rgpv_rec := migrate_rgpv(l_rgpv_rec, g_rgpv_rec);

Line 1190: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN

1186:
1187: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
1188: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1189: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1190: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1191: raise OKC_API.G_EXCEPTION_ERROR;
1192: END IF;
1193: l_rgpv_rec := migrate_rgpv(l_rgpv_rec, g_rgpv_rec);
1194:

Line 1191: raise OKC_API.G_EXCEPTION_ERROR;

1187: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
1188: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1189: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1190: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1191: raise OKC_API.G_EXCEPTION_ERROR;
1192: END IF;
1193: l_rgpv_rec := migrate_rgpv(l_rgpv_rec, g_rgpv_rec);
1194:
1195: OKC_RULE_PVT.create_rule_group(

Line 1204: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

1200: x_msg_data => x_msg_data,
1201: p_rgpv_rec => l_rgpv_rec,
1202: x_rgpv_rec => x_rgpv_rec);
1203:
1204: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1205: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1206: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1207: raise OKC_API.G_EXCEPTION_ERROR;
1208: END IF;

Line 1205: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1201: p_rgpv_rec => l_rgpv_rec,
1202: x_rgpv_rec => x_rgpv_rec);
1203:
1204: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1205: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1206: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1207: raise OKC_API.G_EXCEPTION_ERROR;
1208: END IF;
1209:

Line 1206: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN

1202: x_rgpv_rec => x_rgpv_rec);
1203:
1204: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1205: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1206: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1207: raise OKC_API.G_EXCEPTION_ERROR;
1208: END IF;
1209:
1210: -- Call user hook for AFTER

Line 1207: raise OKC_API.G_EXCEPTION_ERROR;

1203:
1204: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1205: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1206: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1207: raise OKC_API.G_EXCEPTION_ERROR;
1208: END IF;
1209:
1210: -- Call user hook for AFTER
1211: g_rgpv_rec := x_rgpv_rec;

Line 1213: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

1209:
1210: -- Call user hook for AFTER
1211: g_rgpv_rec := x_rgpv_rec;
1212: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
1213: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1214: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1215: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1216: raise OKC_API.G_EXCEPTION_ERROR;
1217: END IF;

Line 1214: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1210: -- Call user hook for AFTER
1211: g_rgpv_rec := x_rgpv_rec;
1212: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
1213: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1214: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1215: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1216: raise OKC_API.G_EXCEPTION_ERROR;
1217: END IF;
1218: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

Line 1215: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN

1211: g_rgpv_rec := x_rgpv_rec;
1212: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
1213: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1214: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1215: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1216: raise OKC_API.G_EXCEPTION_ERROR;
1217: END IF;
1218: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1219:

Line 1216: raise OKC_API.G_EXCEPTION_ERROR;

1212: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
1213: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1214: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1215: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1216: raise OKC_API.G_EXCEPTION_ERROR;
1217: END IF;
1218: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1219:
1220:

Line 1218: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

1214: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1215: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1216: raise OKC_API.G_EXCEPTION_ERROR;
1217: END IF;
1218: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1219:
1220:
1221:
1222:

Line 1224: WHEN OKC_API.G_EXCEPTION_ERROR THEN

1220:
1221:
1222:
1223: EXCEPTION
1224: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1225: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1226: (l_api_name
1227: ,G_PKG_NAME
1228: ,'OKC_API.G_RET_STS_ERROR'

Line 1225: x_return_status := OKC_API.HANDLE_EXCEPTIONS

1221:
1222:
1223: EXCEPTION
1224: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1225: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1226: (l_api_name
1227: ,G_PKG_NAME
1228: ,'OKC_API.G_RET_STS_ERROR'
1229: ,x_msg_count

Line 1228: ,'OKC_API.G_RET_STS_ERROR'

1224: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1225: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1226: (l_api_name
1227: ,G_PKG_NAME
1228: ,'OKC_API.G_RET_STS_ERROR'
1229: ,x_msg_count
1230: ,x_msg_data
1231: ,'_PUB');
1232:

Line 1236: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

1232:
1233:
1234:
1235:
1236: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1237: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1238: (l_api_name
1239: ,G_PKG_NAME
1240: ,'OKC_API.G_RET_STS_UNEXP_ERROR'

Line 1237: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

1233:
1234:
1235:
1236: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1237: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1238: (l_api_name
1239: ,G_PKG_NAME
1240: ,'OKC_API.G_RET_STS_UNEXP_ERROR'
1241: ,x_msg_count

Line 1240: ,'OKC_API.G_RET_STS_UNEXP_ERROR'

1236: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1237: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1238: (l_api_name
1239: ,G_PKG_NAME
1240: ,'OKC_API.G_RET_STS_UNEXP_ERROR'
1241: ,x_msg_count
1242: ,x_msg_data
1243: ,'_PUB');
1244:

Line 1249: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

1245:
1246:
1247:
1248: WHEN OTHERS THEN
1249: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1250: (l_api_name
1251: ,G_PKG_NAME
1252: ,'OTHERS'
1253: ,x_msg_count

Line 1274: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;

1270: x_msg_data OUT NOCOPY VARCHAR2,
1271: p_rgpv_tbl IN rgpv_tbl_type,
1272: x_rgpv_tbl OUT NOCOPY rgpv_tbl_type) IS
1273: i NUMBER := 0;
1274: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1275: --
1276: l_proc varchar2(72) := g_package||'create_rule_group';
1277: --
1278:

Line 1284: x_return_status := OKC_API.G_RET_STS_SUCCESS;

1280:
1281:
1282:
1283:
1284: x_return_status := OKC_API.G_RET_STS_SUCCESS;
1285: IF p_rgpv_tbl.COUNT > 0 THEN
1286: i := p_rgpv_tbl.FIRST;
1287: LOOP
1288: create_rule_group(

Line 1296: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN

1292: x_msg_count => x_msg_count,
1293: x_msg_data => x_msg_data,
1294: p_rgpv_rec => p_rgpv_tbl(i),
1295: x_rgpv_rec => x_rgpv_tbl(i));
1296: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1297: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1298: x_return_status := l_return_status;
1299: raise G_EXCEPTION_HALT_VALIDATION;
1300: ELSE

Line 1297: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

1293: x_msg_data => x_msg_data,
1294: p_rgpv_rec => p_rgpv_tbl(i),
1295: x_rgpv_rec => x_rgpv_tbl(i));
1296: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1297: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1298: x_return_status := l_return_status;
1299: raise G_EXCEPTION_HALT_VALIDATION;
1300: ELSE
1301: x_return_status := l_return_status;

Line 1321: OKC_API.SET_MESSAGE(

1317:
1318: NULL;
1319: WHEN OTHERS THEN
1320: -- store SQL error message on message stack
1321: OKC_API.SET_MESSAGE(
1322: p_app_name => G_APP_NAME,
1323: p_msg_name => G_UNEXPECTED_ERROR,
1324: p_token1 => G_SQLCODE_TOKEN,
1325: p_token1_value => SQLCODE,

Line 1329: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

1325: p_token1_value => SQLCODE,
1326: p_token2 => G_SQLERRM_TOKEN,
1327: p_token2_value => SQLERRM);
1328: -- notify caller of an error as UNEXPETED error
1329: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
1330:
1331:
1332:
1333:

Line 1347: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;

1343: x_msg_count OUT NOCOPY NUMBER,
1344: x_msg_data OUT NOCOPY VARCHAR2,
1345: p_rgpv_rec IN rgpv_rec_type,
1346: x_rgpv_rec OUT NOCOPY rgpv_rec_type) IS
1347: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1348: l_api_name CONSTANT VARCHAR2(30) := 'update_rule_group';
1349: l_rgpv_rec rgpv_rec_type := p_rgpv_rec;
1350: --
1351: l_proc varchar2(72) := g_package||'update_rule_group';

Line 1359: l_return_status := OKC_API.START_ACTIVITY(l_api_name,

1355:
1356:
1357:
1358:
1359: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
1360: p_init_msg_list,
1361: '_PUB',
1362: x_return_status);
1363: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

Line 1363: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

1359: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
1360: p_init_msg_list,
1361: '_PUB',
1362: x_return_status);
1363: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1364: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1365: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1366: raise OKC_API.G_EXCEPTION_ERROR;
1367: END IF;

Line 1364: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1360: p_init_msg_list,
1361: '_PUB',
1362: x_return_status);
1363: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1364: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1365: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1366: raise OKC_API.G_EXCEPTION_ERROR;
1367: END IF;
1368: -- Call user hook for BEFORE

Line 1365: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN

1361: '_PUB',
1362: x_return_status);
1363: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1364: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1365: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1366: raise OKC_API.G_EXCEPTION_ERROR;
1367: END IF;
1368: -- Call user hook for BEFORE
1369: g_rgpv_rec := p_rgpv_rec;

Line 1366: raise OKC_API.G_EXCEPTION_ERROR;

1362: x_return_status);
1363: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1364: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1365: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1366: raise OKC_API.G_EXCEPTION_ERROR;
1367: END IF;
1368: -- Call user hook for BEFORE
1369: g_rgpv_rec := p_rgpv_rec;
1370: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');

Line 1371: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

1367: END IF;
1368: -- Call user hook for BEFORE
1369: g_rgpv_rec := p_rgpv_rec;
1370: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
1371: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1372: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1373: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1374: raise OKC_API.G_EXCEPTION_ERROR;
1375: END IF;

Line 1372: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1368: -- Call user hook for BEFORE
1369: g_rgpv_rec := p_rgpv_rec;
1370: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
1371: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1372: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1373: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1374: raise OKC_API.G_EXCEPTION_ERROR;
1375: END IF;
1376: l_rgpv_rec := migrate_rgpv(l_rgpv_rec, g_rgpv_rec);

Line 1373: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN

1369: g_rgpv_rec := p_rgpv_rec;
1370: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
1371: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1372: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1373: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1374: raise OKC_API.G_EXCEPTION_ERROR;
1375: END IF;
1376: l_rgpv_rec := migrate_rgpv(l_rgpv_rec, g_rgpv_rec);
1377:

Line 1374: raise OKC_API.G_EXCEPTION_ERROR;

1370: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
1371: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1372: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1373: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1374: raise OKC_API.G_EXCEPTION_ERROR;
1375: END IF;
1376: l_rgpv_rec := migrate_rgpv(l_rgpv_rec, g_rgpv_rec);
1377:
1378: OKC_RULE_PVT.update_rule_group(

Line 1387: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

1383: x_msg_data => x_msg_data,
1384: p_rgpv_rec => l_rgpv_rec,
1385: x_rgpv_rec => x_rgpv_rec);
1386:
1387: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1388: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1389: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1390: raise OKC_API.G_EXCEPTION_ERROR;
1391: END IF;

Line 1388: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1384: p_rgpv_rec => l_rgpv_rec,
1385: x_rgpv_rec => x_rgpv_rec);
1386:
1387: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1388: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1389: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1390: raise OKC_API.G_EXCEPTION_ERROR;
1391: END IF;
1392:

Line 1389: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN

1385: x_rgpv_rec => x_rgpv_rec);
1386:
1387: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1388: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1389: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1390: raise OKC_API.G_EXCEPTION_ERROR;
1391: END IF;
1392:
1393: -- Call user hook for AFTER

Line 1390: raise OKC_API.G_EXCEPTION_ERROR;

1386:
1387: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1388: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1389: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1390: raise OKC_API.G_EXCEPTION_ERROR;
1391: END IF;
1392:
1393: -- Call user hook for AFTER
1394: g_rgpv_rec := x_rgpv_rec;

Line 1396: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

1392:
1393: -- Call user hook for AFTER
1394: g_rgpv_rec := x_rgpv_rec;
1395: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
1396: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1397: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1398: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1399: raise OKC_API.G_EXCEPTION_ERROR;
1400: END IF;

Line 1397: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1393: -- Call user hook for AFTER
1394: g_rgpv_rec := x_rgpv_rec;
1395: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
1396: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1397: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1398: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1399: raise OKC_API.G_EXCEPTION_ERROR;
1400: END IF;
1401: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

Line 1398: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN

1394: g_rgpv_rec := x_rgpv_rec;
1395: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
1396: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1397: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1398: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1399: raise OKC_API.G_EXCEPTION_ERROR;
1400: END IF;
1401: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1402:

Line 1399: raise OKC_API.G_EXCEPTION_ERROR;

1395: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
1396: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1397: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1398: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1399: raise OKC_API.G_EXCEPTION_ERROR;
1400: END IF;
1401: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1402:
1403:

Line 1401: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

1397: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1398: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1399: raise OKC_API.G_EXCEPTION_ERROR;
1400: END IF;
1401: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1402:
1403:
1404:
1405:

Line 1407: WHEN OKC_API.G_EXCEPTION_ERROR THEN

1403:
1404:
1405:
1406: EXCEPTION
1407: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1408: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1409: (l_api_name
1410: ,G_PKG_NAME
1411: ,'OKC_API.G_RET_STS_ERROR'

Line 1408: x_return_status := OKC_API.HANDLE_EXCEPTIONS

1404:
1405:
1406: EXCEPTION
1407: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1408: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1409: (l_api_name
1410: ,G_PKG_NAME
1411: ,'OKC_API.G_RET_STS_ERROR'
1412: ,x_msg_count

Line 1411: ,'OKC_API.G_RET_STS_ERROR'

1407: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1408: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1409: (l_api_name
1410: ,G_PKG_NAME
1411: ,'OKC_API.G_RET_STS_ERROR'
1412: ,x_msg_count
1413: ,x_msg_data
1414: ,'_PUB');
1415:

Line 1419: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

1415:
1416:
1417:
1418:
1419: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1420: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1421: (l_api_name
1422: ,G_PKG_NAME
1423: ,'OKC_API.G_RET_STS_UNEXP_ERROR'

Line 1420: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

1416:
1417:
1418:
1419: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1420: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1421: (l_api_name
1422: ,G_PKG_NAME
1423: ,'OKC_API.G_RET_STS_UNEXP_ERROR'
1424: ,x_msg_count

Line 1423: ,'OKC_API.G_RET_STS_UNEXP_ERROR'

1419: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1420: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1421: (l_api_name
1422: ,G_PKG_NAME
1423: ,'OKC_API.G_RET_STS_UNEXP_ERROR'
1424: ,x_msg_count
1425: ,x_msg_data
1426: ,'_PUB');
1427:

Line 1432: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

1428:
1429:
1430:
1431: WHEN OTHERS THEN
1432: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1433: (l_api_name
1434: ,G_PKG_NAME
1435: ,'OTHERS'
1436: ,x_msg_count

Line 1457: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;

1453: x_msg_data OUT NOCOPY VARCHAR2,
1454: p_rgpv_tbl IN rgpv_tbl_type,
1455: x_rgpv_tbl OUT NOCOPY rgpv_tbl_type) IS
1456: i NUMBER := 0;
1457: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1458: --
1459: l_proc varchar2(72) := g_package||'update_rule_group';
1460: --
1461:

Line 1467: x_return_status := OKC_API.G_RET_STS_SUCCESS;

1463:
1464:
1465:
1466:
1467: x_return_status := OKC_API.G_RET_STS_SUCCESS;
1468: IF p_rgpv_tbl.COUNT > 0 THEN
1469: i := p_rgpv_tbl.FIRST;
1470: LOOP
1471: update_rule_group(

Line 1479: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN

1475: x_msg_count => x_msg_count,
1476: x_msg_data => x_msg_data,
1477: p_rgpv_rec => p_rgpv_tbl(i),
1478: x_rgpv_rec => x_rgpv_tbl(i));
1479: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1480: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1481: x_return_status := l_return_status;
1482: raise G_EXCEPTION_HALT_VALIDATION;
1483: ELSE

Line 1480: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

1476: x_msg_data => x_msg_data,
1477: p_rgpv_rec => p_rgpv_tbl(i),
1478: x_rgpv_rec => x_rgpv_tbl(i));
1479: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1480: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1481: x_return_status := l_return_status;
1482: raise G_EXCEPTION_HALT_VALIDATION;
1483: ELSE
1484: x_return_status := l_return_status;

Line 1504: OKC_API.SET_MESSAGE(

1500:
1501: NULL;
1502: WHEN OTHERS THEN
1503: -- store SQL error message on message stack
1504: OKC_API.SET_MESSAGE(
1505: p_app_name => G_APP_NAME,
1506: p_msg_name => G_UNEXPECTED_ERROR,
1507: p_token1 => G_SQLCODE_TOKEN,
1508: p_token1_value => SQLCODE,

Line 1512: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

1508: p_token1_value => SQLCODE,
1509: p_token2 => G_SQLERRM_TOKEN,
1510: p_token2_value => SQLERRM);
1511: -- notify caller of an error as UNEXPETED error
1512: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
1513:
1514:
1515:
1516:

Line 1529: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;

1525: x_return_status OUT NOCOPY VARCHAR2,
1526: x_msg_count OUT NOCOPY NUMBER,
1527: x_msg_data OUT NOCOPY VARCHAR2,
1528: p_rgpv_rec IN rgpv_rec_type) IS
1529: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1530: l_api_name CONSTANT VARCHAR2(30) := 'delete_rule_group';
1531: l_rgpv_rec rgpv_rec_type := p_rgpv_rec;
1532: --
1533: l_proc varchar2(72) := g_package||'delete_rule_group';

Line 1541: l_return_status := OKC_API.START_ACTIVITY(l_api_name,

1537:
1538:
1539:
1540:
1541: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
1542: p_init_msg_list,
1543: '_PUB',
1544: x_return_status);
1545: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

Line 1545: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

1541: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
1542: p_init_msg_list,
1543: '_PUB',
1544: x_return_status);
1545: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1546: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1547: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1548: raise OKC_API.G_EXCEPTION_ERROR;
1549: END IF;

Line 1546: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1542: p_init_msg_list,
1543: '_PUB',
1544: x_return_status);
1545: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1546: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1547: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1548: raise OKC_API.G_EXCEPTION_ERROR;
1549: END IF;
1550: -- Call user hook for BEFORE

Line 1547: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN

1543: '_PUB',
1544: x_return_status);
1545: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1546: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1547: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1548: raise OKC_API.G_EXCEPTION_ERROR;
1549: END IF;
1550: -- Call user hook for BEFORE
1551: g_rgpv_rec := p_rgpv_rec;

Line 1548: raise OKC_API.G_EXCEPTION_ERROR;

1544: x_return_status);
1545: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1546: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1547: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1548: raise OKC_API.G_EXCEPTION_ERROR;
1549: END IF;
1550: -- Call user hook for BEFORE
1551: g_rgpv_rec := p_rgpv_rec;
1552: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');

Line 1553: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

1549: END IF;
1550: -- Call user hook for BEFORE
1551: g_rgpv_rec := p_rgpv_rec;
1552: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
1553: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1554: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1555: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1556: raise OKC_API.G_EXCEPTION_ERROR;
1557: END IF;

Line 1554: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1550: -- Call user hook for BEFORE
1551: g_rgpv_rec := p_rgpv_rec;
1552: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
1553: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1554: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1555: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1556: raise OKC_API.G_EXCEPTION_ERROR;
1557: END IF;
1558:

Line 1555: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN

1551: g_rgpv_rec := p_rgpv_rec;
1552: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
1553: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1554: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1555: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1556: raise OKC_API.G_EXCEPTION_ERROR;
1557: END IF;
1558:
1559: OKC_RULE_PVT.delete_rule_group(

Line 1556: raise OKC_API.G_EXCEPTION_ERROR;

1552: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
1553: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1554: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1555: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1556: raise OKC_API.G_EXCEPTION_ERROR;
1557: END IF;
1558:
1559: OKC_RULE_PVT.delete_rule_group(
1560: p_api_version => p_api_version,

Line 1567: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

1563: x_msg_count => x_msg_count,
1564: x_msg_data => x_msg_data,
1565: p_rgpv_rec => p_rgpv_rec);
1566:
1567: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1568: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1569: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1570: raise OKC_API.G_EXCEPTION_ERROR;
1571: END IF;

Line 1568: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1564: x_msg_data => x_msg_data,
1565: p_rgpv_rec => p_rgpv_rec);
1566:
1567: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1568: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1569: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1570: raise OKC_API.G_EXCEPTION_ERROR;
1571: END IF;
1572:

Line 1569: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN

1565: p_rgpv_rec => p_rgpv_rec);
1566:
1567: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1568: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1569: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1570: raise OKC_API.G_EXCEPTION_ERROR;
1571: END IF;
1572:
1573: -- Call user hook for AFTER

Line 1570: raise OKC_API.G_EXCEPTION_ERROR;

1566:
1567: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1568: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1569: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1570: raise OKC_API.G_EXCEPTION_ERROR;
1571: END IF;
1572:
1573: -- Call user hook for AFTER
1574: g_rgpv_rec := l_rgpv_rec;

Line 1576: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

1572:
1573: -- Call user hook for AFTER
1574: g_rgpv_rec := l_rgpv_rec;
1575: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
1576: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1577: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1578: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1579: raise OKC_API.G_EXCEPTION_ERROR;
1580: END IF;

Line 1577: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1573: -- Call user hook for AFTER
1574: g_rgpv_rec := l_rgpv_rec;
1575: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
1576: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1577: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1578: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1579: raise OKC_API.G_EXCEPTION_ERROR;
1580: END IF;
1581: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

Line 1578: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN

1574: g_rgpv_rec := l_rgpv_rec;
1575: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
1576: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1577: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1578: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1579: raise OKC_API.G_EXCEPTION_ERROR;
1580: END IF;
1581: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1582:

Line 1579: raise OKC_API.G_EXCEPTION_ERROR;

1575: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
1576: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1577: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1578: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1579: raise OKC_API.G_EXCEPTION_ERROR;
1580: END IF;
1581: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1582:
1583:

Line 1581: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

1577: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1578: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1579: raise OKC_API.G_EXCEPTION_ERROR;
1580: END IF;
1581: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1582:
1583:
1584:
1585:

Line 1587: WHEN OKC_API.G_EXCEPTION_ERROR THEN

1583:
1584:
1585:
1586: EXCEPTION
1587: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1588: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1589: (l_api_name
1590: ,G_PKG_NAME
1591: ,'OKC_API.G_RET_STS_ERROR'

Line 1588: x_return_status := OKC_API.HANDLE_EXCEPTIONS

1584:
1585:
1586: EXCEPTION
1587: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1588: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1589: (l_api_name
1590: ,G_PKG_NAME
1591: ,'OKC_API.G_RET_STS_ERROR'
1592: ,x_msg_count

Line 1591: ,'OKC_API.G_RET_STS_ERROR'

1587: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1588: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1589: (l_api_name
1590: ,G_PKG_NAME
1591: ,'OKC_API.G_RET_STS_ERROR'
1592: ,x_msg_count
1593: ,x_msg_data
1594: ,'_PUB');
1595:

Line 1599: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

1595:
1596:
1597:
1598:
1599: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1600: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1601: (l_api_name
1602: ,G_PKG_NAME
1603: ,'OKC_API.G_RET_STS_UNEXP_ERROR'

Line 1600: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

1596:
1597:
1598:
1599: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1600: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1601: (l_api_name
1602: ,G_PKG_NAME
1603: ,'OKC_API.G_RET_STS_UNEXP_ERROR'
1604: ,x_msg_count

Line 1603: ,'OKC_API.G_RET_STS_UNEXP_ERROR'

1599: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1600: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1601: (l_api_name
1602: ,G_PKG_NAME
1603: ,'OKC_API.G_RET_STS_UNEXP_ERROR'
1604: ,x_msg_count
1605: ,x_msg_data
1606: ,'_PUB');
1607:

Line 1612: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

1608:
1609:
1610:
1611: WHEN OTHERS THEN
1612: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1613: (l_api_name
1614: ,G_PKG_NAME
1615: ,'OTHERS'
1616: ,x_msg_count

Line 1636: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;

1632: x_msg_count OUT NOCOPY NUMBER,
1633: x_msg_data OUT NOCOPY VARCHAR2,
1634: p_rgpv_tbl IN rgpv_tbl_type) IS
1635: i NUMBER := 0;
1636: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1637: --
1638: l_proc varchar2(72) := g_package||'delete_rule_group';
1639: --
1640:

Line 1646: x_return_status := OKC_API.G_RET_STS_SUCCESS;

1642:
1643:
1644:
1645:
1646: x_return_status := OKC_API.G_RET_STS_SUCCESS;
1647: IF p_rgpv_tbl.COUNT > 0 THEN
1648: i := p_rgpv_tbl.FIRST;
1649: LOOP
1650: delete_rule_group(

Line 1657: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN

1653: x_return_status => l_return_status,
1654: x_msg_count => x_msg_count,
1655: x_msg_data => x_msg_data,
1656: p_rgpv_rec => p_rgpv_tbl(i));
1657: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1658: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1659: x_return_status := l_return_status;
1660: raise G_EXCEPTION_HALT_VALIDATION;
1661: ELSE

Line 1658: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

1654: x_msg_count => x_msg_count,
1655: x_msg_data => x_msg_data,
1656: p_rgpv_rec => p_rgpv_tbl(i));
1657: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1658: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1659: x_return_status := l_return_status;
1660: raise G_EXCEPTION_HALT_VALIDATION;
1661: ELSE
1662: x_return_status := l_return_status;

Line 1682: OKC_API.SET_MESSAGE(

1678:
1679: NULL;
1680: WHEN OTHERS THEN
1681: -- store SQL error message on message stack
1682: OKC_API.SET_MESSAGE(
1683: p_app_name => G_APP_NAME,
1684: p_msg_name => G_UNEXPECTED_ERROR,
1685: p_token1 => G_SQLCODE_TOKEN,
1686: p_token1_value => SQLCODE,

Line 1690: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

1686: p_token1_value => SQLCODE,
1687: p_token2 => G_SQLERRM_TOKEN,
1688: p_token2_value => SQLERRM);
1689: -- notify caller of an error as UNEXPETED error
1690: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
1691:
1692:
1693:
1694:

Line 1740: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;

1736: x_msg_count OUT NOCOPY NUMBER,
1737: x_msg_data OUT NOCOPY VARCHAR2,
1738: p_rgpv_tbl IN rgpv_tbl_type) IS
1739: i NUMBER := 0;
1740: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1741: --
1742: l_proc varchar2(72) := g_package||'lock_rule_group';
1743: --
1744:

Line 1750: x_return_status := OKC_API.G_RET_STS_SUCCESS;

1746:
1747:
1748:
1749:
1750: x_return_status := OKC_API.G_RET_STS_SUCCESS;
1751: IF p_rgpv_tbl.COUNT > 0 THEN
1752: i := p_rgpv_tbl.FIRST;
1753: LOOP
1754: lock_rule_group(

Line 1761: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN

1757: x_return_status => l_return_status,
1758: x_msg_count => x_msg_count,
1759: x_msg_data => x_msg_data,
1760: p_rgpv_rec => p_rgpv_tbl(i));
1761: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1762: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1763: x_return_status := l_return_status;
1764: raise G_EXCEPTION_HALT_VALIDATION;
1765: ELSE

Line 1762: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

1758: x_msg_count => x_msg_count,
1759: x_msg_data => x_msg_data,
1760: p_rgpv_rec => p_rgpv_tbl(i));
1761: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1762: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1763: x_return_status := l_return_status;
1764: raise G_EXCEPTION_HALT_VALIDATION;
1765: ELSE
1766: x_return_status := l_return_status;

Line 1786: OKC_API.SET_MESSAGE(

1782:
1783: NULL;
1784: WHEN OTHERS THEN
1785: -- store SQL error message on message stack
1786: OKC_API.SET_MESSAGE(
1787: p_app_name => G_APP_NAME,
1788: p_msg_name => G_UNEXPECTED_ERROR,
1789: p_token1 => G_SQLCODE_TOKEN,
1790: p_token1_value => SQLCODE,

Line 1794: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

1790: p_token1_value => SQLCODE,
1791: p_token2 => G_SQLERRM_TOKEN,
1792: p_token2_value => SQLERRM);
1793: -- notify caller of an error as UNEXPETED error
1794: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
1795:
1796:
1797:
1798:

Line 1811: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;

1807: x_return_status OUT NOCOPY VARCHAR2,
1808: x_msg_count OUT NOCOPY NUMBER,
1809: x_msg_data OUT NOCOPY VARCHAR2,
1810: p_rgpv_rec IN rgpv_rec_type) IS
1811: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1812: l_api_name CONSTANT VARCHAR2(30) := 'validate_rule_group';
1813: l_rgpv_rec rgpv_rec_type := p_rgpv_rec;
1814: --
1815: l_proc varchar2(72) := g_package||'validate_rule_group';

Line 1823: l_return_status := OKC_API.START_ACTIVITY(l_api_name,

1819:
1820:
1821:
1822:
1823: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
1824: p_init_msg_list,
1825: '_PUB',
1826: x_return_status);
1827: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

Line 1827: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

1823: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
1824: p_init_msg_list,
1825: '_PUB',
1826: x_return_status);
1827: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1828: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1829: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1830: raise OKC_API.G_EXCEPTION_ERROR;
1831: END IF;

Line 1828: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1824: p_init_msg_list,
1825: '_PUB',
1826: x_return_status);
1827: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1828: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1829: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1830: raise OKC_API.G_EXCEPTION_ERROR;
1831: END IF;
1832: -- Call user hook for BEFORE

Line 1829: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN

1825: '_PUB',
1826: x_return_status);
1827: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1828: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1829: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1830: raise OKC_API.G_EXCEPTION_ERROR;
1831: END IF;
1832: -- Call user hook for BEFORE
1833: g_rgpv_rec := p_rgpv_rec;

Line 1830: raise OKC_API.G_EXCEPTION_ERROR;

1826: x_return_status);
1827: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1828: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1829: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1830: raise OKC_API.G_EXCEPTION_ERROR;
1831: END IF;
1832: -- Call user hook for BEFORE
1833: g_rgpv_rec := p_rgpv_rec;
1834: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');

Line 1835: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

1831: END IF;
1832: -- Call user hook for BEFORE
1833: g_rgpv_rec := p_rgpv_rec;
1834: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
1835: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1836: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1837: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1838: raise OKC_API.G_EXCEPTION_ERROR;
1839: END IF;

Line 1836: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1832: -- Call user hook for BEFORE
1833: g_rgpv_rec := p_rgpv_rec;
1834: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
1835: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1836: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1837: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1838: raise OKC_API.G_EXCEPTION_ERROR;
1839: END IF;
1840:

Line 1837: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN

1833: g_rgpv_rec := p_rgpv_rec;
1834: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
1835: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1836: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1837: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1838: raise OKC_API.G_EXCEPTION_ERROR;
1839: END IF;
1840:
1841: OKC_RULE_PVT.validate_rule_group(

Line 1838: raise OKC_API.G_EXCEPTION_ERROR;

1834: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
1835: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1836: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1837: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1838: raise OKC_API.G_EXCEPTION_ERROR;
1839: END IF;
1840:
1841: OKC_RULE_PVT.validate_rule_group(
1842: p_api_version => p_api_version,

Line 1849: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

1845: x_msg_count => x_msg_count,
1846: x_msg_data => x_msg_data,
1847: p_rgpv_rec => p_rgpv_rec);
1848:
1849: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1850: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1851: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1852: raise OKC_API.G_EXCEPTION_ERROR;
1853: END IF;

Line 1850: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1846: x_msg_data => x_msg_data,
1847: p_rgpv_rec => p_rgpv_rec);
1848:
1849: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1850: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1851: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1852: raise OKC_API.G_EXCEPTION_ERROR;
1853: END IF;
1854:

Line 1851: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN

1847: p_rgpv_rec => p_rgpv_rec);
1848:
1849: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1850: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1851: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1852: raise OKC_API.G_EXCEPTION_ERROR;
1853: END IF;
1854:
1855: -- Call user hook for AFTER

Line 1852: raise OKC_API.G_EXCEPTION_ERROR;

1848:
1849: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1850: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1851: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1852: raise OKC_API.G_EXCEPTION_ERROR;
1853: END IF;
1854:
1855: -- Call user hook for AFTER
1856: g_rgpv_rec := l_rgpv_rec;

Line 1858: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

1854:
1855: -- Call user hook for AFTER
1856: g_rgpv_rec := l_rgpv_rec;
1857: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
1858: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1859: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1860: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1861: raise OKC_API.G_EXCEPTION_ERROR;
1862: END IF;

Line 1859: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1855: -- Call user hook for AFTER
1856: g_rgpv_rec := l_rgpv_rec;
1857: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
1858: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1859: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1860: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1861: raise OKC_API.G_EXCEPTION_ERROR;
1862: END IF;
1863: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

Line 1860: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN

1856: g_rgpv_rec := l_rgpv_rec;
1857: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
1858: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1859: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1860: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1861: raise OKC_API.G_EXCEPTION_ERROR;
1862: END IF;
1863: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1864:

Line 1861: raise OKC_API.G_EXCEPTION_ERROR;

1857: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
1858: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1859: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1860: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1861: raise OKC_API.G_EXCEPTION_ERROR;
1862: END IF;
1863: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1864:
1865:

Line 1863: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

1859: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1860: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1861: raise OKC_API.G_EXCEPTION_ERROR;
1862: END IF;
1863: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1864:
1865:
1866:
1867:

Line 1869: WHEN OKC_API.G_EXCEPTION_ERROR THEN

1865:
1866:
1867:
1868: EXCEPTION
1869: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1870: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1871: (l_api_name
1872: ,G_PKG_NAME
1873: ,'OKC_API.G_RET_STS_ERROR'

Line 1870: x_return_status := OKC_API.HANDLE_EXCEPTIONS

1866:
1867:
1868: EXCEPTION
1869: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1870: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1871: (l_api_name
1872: ,G_PKG_NAME
1873: ,'OKC_API.G_RET_STS_ERROR'
1874: ,x_msg_count

Line 1873: ,'OKC_API.G_RET_STS_ERROR'

1869: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1870: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1871: (l_api_name
1872: ,G_PKG_NAME
1873: ,'OKC_API.G_RET_STS_ERROR'
1874: ,x_msg_count
1875: ,x_msg_data
1876: ,'_PUB');
1877:

Line 1881: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

1877:
1878:
1879:
1880:
1881: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1882: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1883: (l_api_name
1884: ,G_PKG_NAME
1885: ,'OKC_API.G_RET_STS_UNEXP_ERROR'

Line 1882: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

1878:
1879:
1880:
1881: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1882: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1883: (l_api_name
1884: ,G_PKG_NAME
1885: ,'OKC_API.G_RET_STS_UNEXP_ERROR'
1886: ,x_msg_count

Line 1885: ,'OKC_API.G_RET_STS_UNEXP_ERROR'

1881: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1882: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1883: (l_api_name
1884: ,G_PKG_NAME
1885: ,'OKC_API.G_RET_STS_UNEXP_ERROR'
1886: ,x_msg_count
1887: ,x_msg_data
1888: ,'_PUB');
1889:

Line 1894: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

1890:
1891:
1892:
1893: WHEN OTHERS THEN
1894: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1895: (l_api_name
1896: ,G_PKG_NAME
1897: ,'OTHERS'
1898: ,x_msg_count

Line 1918: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;

1914: x_msg_count OUT NOCOPY NUMBER,
1915: x_msg_data OUT NOCOPY VARCHAR2,
1916: p_rgpv_tbl IN rgpv_tbl_type) IS
1917: i NUMBER := 0;
1918: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1919: --
1920: l_proc varchar2(72) := g_package||'validate_rule_group';
1921: --
1922:

Line 1928: x_return_status := OKC_API.G_RET_STS_SUCCESS;

1924:
1925:
1926:
1927:
1928: x_return_status := OKC_API.G_RET_STS_SUCCESS;
1929: IF p_rgpv_tbl.COUNT > 0 THEN
1930: i := p_rgpv_tbl.FIRST;
1931: LOOP
1932: validate_rule_group(

Line 1939: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN

1935: x_return_status => l_return_status,
1936: x_msg_count => x_msg_count,
1937: x_msg_data => x_msg_data,
1938: p_rgpv_rec => p_rgpv_tbl(i));
1939: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1940: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1941: x_return_status := l_return_status;
1942: raise G_EXCEPTION_HALT_VALIDATION;
1943: ELSE

Line 1940: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

1936: x_msg_count => x_msg_count,
1937: x_msg_data => x_msg_data,
1938: p_rgpv_rec => p_rgpv_tbl(i));
1939: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1940: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1941: x_return_status := l_return_status;
1942: raise G_EXCEPTION_HALT_VALIDATION;
1943: ELSE
1944: x_return_status := l_return_status;

Line 1964: OKC_API.SET_MESSAGE(

1960:
1961: NULL;
1962: WHEN OTHERS THEN
1963: -- store SQL error message on message stack
1964: OKC_API.SET_MESSAGE(
1965: p_app_name => G_APP_NAME,
1966: p_msg_name => G_UNEXPECTED_ERROR,
1967: p_token1 => G_SQLCODE_TOKEN,
1968: p_token1_value => SQLCODE,

Line 1972: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

1968: p_token1_value => SQLCODE,
1969: p_token2 => G_SQLERRM_TOKEN,
1970: p_token2_value => SQLERRM);
1971: -- notify caller of an error as UNEXPETED error
1972: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
1973:
1974:
1975:
1976:

Line 2023: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;

2019: x_msg_count OUT NOCOPY NUMBER,
2020: x_msg_data OUT NOCOPY VARCHAR2,
2021: p_rmpv_rec IN rmpv_rec_type,
2022: x_rmpv_rec OUT NOCOPY rmpv_rec_type) IS
2023: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2024: l_api_name CONSTANT VARCHAR2(30) := 'create_rg_mode_pty_role';
2025: l_rmpv_rec rmpv_rec_type := p_rmpv_rec;
2026: --
2027: l_proc varchar2(72) := g_package||'create_rg_mode_pty_role';

Line 2035: l_return_status := OKC_API.START_ACTIVITY(l_api_name,

2031:
2032:
2033:
2034:
2035: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
2036: p_init_msg_list,
2037: '_PUB',
2038: x_return_status);
2039: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

Line 2039: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

2035: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
2036: p_init_msg_list,
2037: '_PUB',
2038: x_return_status);
2039: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2040: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2041: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2042: raise OKC_API.G_EXCEPTION_ERROR;
2043: END IF;

Line 2040: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2036: p_init_msg_list,
2037: '_PUB',
2038: x_return_status);
2039: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2040: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2041: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2042: raise OKC_API.G_EXCEPTION_ERROR;
2043: END IF;
2044: -- Call user hook for BEFORE

Line 2041: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN

2037: '_PUB',
2038: x_return_status);
2039: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2040: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2041: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2042: raise OKC_API.G_EXCEPTION_ERROR;
2043: END IF;
2044: -- Call user hook for BEFORE
2045: g_rmpv_rec := p_rmpv_rec;

Line 2042: raise OKC_API.G_EXCEPTION_ERROR;

2038: x_return_status);
2039: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2040: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2041: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2042: raise OKC_API.G_EXCEPTION_ERROR;
2043: END IF;
2044: -- Call user hook for BEFORE
2045: g_rmpv_rec := p_rmpv_rec;
2046: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');

Line 2047: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

2043: END IF;
2044: -- Call user hook for BEFORE
2045: g_rmpv_rec := p_rmpv_rec;
2046: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
2047: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2048: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2049: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2050: raise OKC_API.G_EXCEPTION_ERROR;
2051: END IF;

Line 2048: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2044: -- Call user hook for BEFORE
2045: g_rmpv_rec := p_rmpv_rec;
2046: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
2047: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2048: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2049: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2050: raise OKC_API.G_EXCEPTION_ERROR;
2051: END IF;
2052: l_rmpv_rec := migrate_rmpv(l_rmpv_rec, g_rmpv_rec);

Line 2049: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN

2045: g_rmpv_rec := p_rmpv_rec;
2046: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
2047: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2048: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2049: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2050: raise OKC_API.G_EXCEPTION_ERROR;
2051: END IF;
2052: l_rmpv_rec := migrate_rmpv(l_rmpv_rec, g_rmpv_rec);
2053:

Line 2050: raise OKC_API.G_EXCEPTION_ERROR;

2046: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
2047: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2048: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2049: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2050: raise OKC_API.G_EXCEPTION_ERROR;
2051: END IF;
2052: l_rmpv_rec := migrate_rmpv(l_rmpv_rec, g_rmpv_rec);
2053:
2054: OKC_RULE_PVT.create_rg_mode_pty_role(

Line 2063: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

2059: x_msg_data => x_msg_data,
2060: p_rmpv_rec => l_rmpv_rec,
2061: x_rmpv_rec => x_rmpv_rec);
2062:
2063: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2064: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2065: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2066: raise OKC_API.G_EXCEPTION_ERROR;
2067: END IF;

Line 2064: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2060: p_rmpv_rec => l_rmpv_rec,
2061: x_rmpv_rec => x_rmpv_rec);
2062:
2063: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2064: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2065: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2066: raise OKC_API.G_EXCEPTION_ERROR;
2067: END IF;
2068:

Line 2065: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN

2061: x_rmpv_rec => x_rmpv_rec);
2062:
2063: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2064: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2065: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2066: raise OKC_API.G_EXCEPTION_ERROR;
2067: END IF;
2068:
2069: -- Call user hook for AFTER

Line 2066: raise OKC_API.G_EXCEPTION_ERROR;

2062:
2063: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2064: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2065: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2066: raise OKC_API.G_EXCEPTION_ERROR;
2067: END IF;
2068:
2069: -- Call user hook for AFTER
2070: g_rmpv_rec := x_rmpv_rec;

Line 2072: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

2068:
2069: -- Call user hook for AFTER
2070: g_rmpv_rec := x_rmpv_rec;
2071: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
2072: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2073: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2074: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2075: raise OKC_API.G_EXCEPTION_ERROR;
2076: END IF;

Line 2073: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2069: -- Call user hook for AFTER
2070: g_rmpv_rec := x_rmpv_rec;
2071: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
2072: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2073: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2074: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2075: raise OKC_API.G_EXCEPTION_ERROR;
2076: END IF;
2077: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

Line 2074: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN

2070: g_rmpv_rec := x_rmpv_rec;
2071: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
2072: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2073: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2074: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2075: raise OKC_API.G_EXCEPTION_ERROR;
2076: END IF;
2077: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
2078:

Line 2075: raise OKC_API.G_EXCEPTION_ERROR;

2071: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
2072: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2073: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2074: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2075: raise OKC_API.G_EXCEPTION_ERROR;
2076: END IF;
2077: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
2078:
2079:

Line 2077: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

2073: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2074: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2075: raise OKC_API.G_EXCEPTION_ERROR;
2076: END IF;
2077: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
2078:
2079:
2080:
2081:

Line 2083: WHEN OKC_API.G_EXCEPTION_ERROR THEN

2079:
2080:
2081:
2082: EXCEPTION
2083: WHEN OKC_API.G_EXCEPTION_ERROR THEN
2084: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2085: (l_api_name
2086: ,G_PKG_NAME
2087: ,'OKC_API.G_RET_STS_ERROR'

Line 2084: x_return_status := OKC_API.HANDLE_EXCEPTIONS

2080:
2081:
2082: EXCEPTION
2083: WHEN OKC_API.G_EXCEPTION_ERROR THEN
2084: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2085: (l_api_name
2086: ,G_PKG_NAME
2087: ,'OKC_API.G_RET_STS_ERROR'
2088: ,x_msg_count

Line 2087: ,'OKC_API.G_RET_STS_ERROR'

2083: WHEN OKC_API.G_EXCEPTION_ERROR THEN
2084: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2085: (l_api_name
2086: ,G_PKG_NAME
2087: ,'OKC_API.G_RET_STS_ERROR'
2088: ,x_msg_count
2089: ,x_msg_data
2090: ,'_PUB');
2091:

Line 2095: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

2091:
2092:
2093:
2094:
2095: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
2096: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
2097: (l_api_name
2098: ,G_PKG_NAME
2099: ,'OKC_API.G_RET_STS_UNEXP_ERROR'

Line 2096: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

2092:
2093:
2094:
2095: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
2096: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
2097: (l_api_name
2098: ,G_PKG_NAME
2099: ,'OKC_API.G_RET_STS_UNEXP_ERROR'
2100: ,x_msg_count

Line 2099: ,'OKC_API.G_RET_STS_UNEXP_ERROR'

2095: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
2096: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
2097: (l_api_name
2098: ,G_PKG_NAME
2099: ,'OKC_API.G_RET_STS_UNEXP_ERROR'
2100: ,x_msg_count
2101: ,x_msg_data
2102: ,'_PUB');
2103:

Line 2108: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

2104:
2105:
2106:
2107: WHEN OTHERS THEN
2108: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
2109: (l_api_name
2110: ,G_PKG_NAME
2111: ,'OTHERS'
2112: ,x_msg_count

Line 2133: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;

2129: x_msg_data OUT NOCOPY VARCHAR2,
2130: p_rmpv_tbl IN rmpv_tbl_type,
2131: x_rmpv_tbl OUT NOCOPY rmpv_tbl_type) IS
2132: i NUMBER := 0;
2133: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2134: --
2135: l_proc varchar2(72) := g_package||'create_rg_mode_pty_role';
2136: --
2137:

Line 2143: x_return_status := OKC_API.G_RET_STS_SUCCESS;

2139:
2140:
2141:
2142:
2143: x_return_status := OKC_API.G_RET_STS_SUCCESS;
2144: IF p_rmpv_tbl.COUNT > 0 THEN
2145: i := p_rmpv_tbl.FIRST;
2146: LOOP
2147: create_rg_mode_pty_role(

Line 2155: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN

2151: x_msg_count => x_msg_count,
2152: x_msg_data => x_msg_data,
2153: p_rmpv_rec => p_rmpv_tbl(i),
2154: x_rmpv_rec => x_rmpv_tbl(i));
2155: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2156: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2157: x_return_status := l_return_status;
2158: raise G_EXCEPTION_HALT_VALIDATION;
2159: ELSE

Line 2156: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

2152: x_msg_data => x_msg_data,
2153: p_rmpv_rec => p_rmpv_tbl(i),
2154: x_rmpv_rec => x_rmpv_tbl(i));
2155: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2156: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2157: x_return_status := l_return_status;
2158: raise G_EXCEPTION_HALT_VALIDATION;
2159: ELSE
2160: x_return_status := l_return_status;

Line 2180: OKC_API.SET_MESSAGE(

2176:
2177: NULL;
2178: WHEN OTHERS THEN
2179: -- store SQL error message on message stack
2180: OKC_API.SET_MESSAGE(
2181: p_app_name => G_APP_NAME,
2182: p_msg_name => G_UNEXPECTED_ERROR,
2183: p_token1 => G_SQLCODE_TOKEN,
2184: p_token1_value => SQLCODE,

Line 2188: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

2184: p_token1_value => SQLCODE,
2185: p_token2 => G_SQLERRM_TOKEN,
2186: p_token2_value => SQLERRM);
2187: -- notify caller of an error as UNEXPETED error
2188: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
2189:
2190:
2191:
2192:

Line 2206: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;

2202: x_msg_count OUT NOCOPY NUMBER,
2203: x_msg_data OUT NOCOPY VARCHAR2,
2204: p_rmpv_rec IN rmpv_rec_type,
2205: x_rmpv_rec OUT NOCOPY rmpv_rec_type) IS
2206: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2207: l_api_name CONSTANT VARCHAR2(30) := 'update_rg_mode_pty_role';
2208: l_rmpv_rec rmpv_rec_type := p_rmpv_rec;
2209: --
2210: l_proc varchar2(72) := g_package||'update_rg_mode_pty_role';

Line 2218: l_return_status := OKC_API.START_ACTIVITY(l_api_name,

2214:
2215:
2216:
2217:
2218: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
2219: p_init_msg_list,
2220: '_PUB',
2221: x_return_status);
2222: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

Line 2222: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

2218: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
2219: p_init_msg_list,
2220: '_PUB',
2221: x_return_status);
2222: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2223: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2224: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2225: raise OKC_API.G_EXCEPTION_ERROR;
2226: END IF;

Line 2223: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2219: p_init_msg_list,
2220: '_PUB',
2221: x_return_status);
2222: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2223: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2224: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2225: raise OKC_API.G_EXCEPTION_ERROR;
2226: END IF;
2227: -- Call user hook for BEFORE

Line 2224: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN

2220: '_PUB',
2221: x_return_status);
2222: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2223: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2224: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2225: raise OKC_API.G_EXCEPTION_ERROR;
2226: END IF;
2227: -- Call user hook for BEFORE
2228: g_rmpv_rec := p_rmpv_rec;

Line 2225: raise OKC_API.G_EXCEPTION_ERROR;

2221: x_return_status);
2222: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2223: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2224: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2225: raise OKC_API.G_EXCEPTION_ERROR;
2226: END IF;
2227: -- Call user hook for BEFORE
2228: g_rmpv_rec := p_rmpv_rec;
2229: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');

Line 2230: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

2226: END IF;
2227: -- Call user hook for BEFORE
2228: g_rmpv_rec := p_rmpv_rec;
2229: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
2230: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2231: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2232: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2233: raise OKC_API.G_EXCEPTION_ERROR;
2234: END IF;

Line 2231: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2227: -- Call user hook for BEFORE
2228: g_rmpv_rec := p_rmpv_rec;
2229: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
2230: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2231: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2232: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2233: raise OKC_API.G_EXCEPTION_ERROR;
2234: END IF;
2235: l_rmpv_rec := migrate_rmpv(l_rmpv_rec, g_rmpv_rec);

Line 2232: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN

2228: g_rmpv_rec := p_rmpv_rec;
2229: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
2230: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2231: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2232: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2233: raise OKC_API.G_EXCEPTION_ERROR;
2234: END IF;
2235: l_rmpv_rec := migrate_rmpv(l_rmpv_rec, g_rmpv_rec);
2236:

Line 2233: raise OKC_API.G_EXCEPTION_ERROR;

2229: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
2230: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2231: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2232: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2233: raise OKC_API.G_EXCEPTION_ERROR;
2234: END IF;
2235: l_rmpv_rec := migrate_rmpv(l_rmpv_rec, g_rmpv_rec);
2236:
2237: OKC_RULE_PVT.update_rg_mode_pty_role(

Line 2246: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

2242: x_msg_data => x_msg_data,
2243: p_rmpv_rec => l_rmpv_rec,
2244: x_rmpv_rec => x_rmpv_rec);
2245:
2246: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2247: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2248: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2249: raise OKC_API.G_EXCEPTION_ERROR;
2250: END IF;

Line 2247: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2243: p_rmpv_rec => l_rmpv_rec,
2244: x_rmpv_rec => x_rmpv_rec);
2245:
2246: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2247: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2248: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2249: raise OKC_API.G_EXCEPTION_ERROR;
2250: END IF;
2251:

Line 2248: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN

2244: x_rmpv_rec => x_rmpv_rec);
2245:
2246: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2247: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2248: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2249: raise OKC_API.G_EXCEPTION_ERROR;
2250: END IF;
2251:
2252: -- Call user hook for AFTER

Line 2249: raise OKC_API.G_EXCEPTION_ERROR;

2245:
2246: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2247: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2248: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2249: raise OKC_API.G_EXCEPTION_ERROR;
2250: END IF;
2251:
2252: -- Call user hook for AFTER
2253: g_rmpv_rec := x_rmpv_rec;

Line 2255: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

2251:
2252: -- Call user hook for AFTER
2253: g_rmpv_rec := x_rmpv_rec;
2254: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
2255: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2256: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2257: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2258: raise OKC_API.G_EXCEPTION_ERROR;
2259: END IF;

Line 2256: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2252: -- Call user hook for AFTER
2253: g_rmpv_rec := x_rmpv_rec;
2254: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
2255: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2256: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2257: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2258: raise OKC_API.G_EXCEPTION_ERROR;
2259: END IF;
2260: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

Line 2257: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN

2253: g_rmpv_rec := x_rmpv_rec;
2254: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
2255: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2256: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2257: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2258: raise OKC_API.G_EXCEPTION_ERROR;
2259: END IF;
2260: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
2261:

Line 2258: raise OKC_API.G_EXCEPTION_ERROR;

2254: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
2255: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2256: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2257: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2258: raise OKC_API.G_EXCEPTION_ERROR;
2259: END IF;
2260: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
2261:
2262:

Line 2260: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

2256: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2257: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2258: raise OKC_API.G_EXCEPTION_ERROR;
2259: END IF;
2260: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
2261:
2262:
2263:
2264:

Line 2266: WHEN OKC_API.G_EXCEPTION_ERROR THEN

2262:
2263:
2264:
2265: EXCEPTION
2266: WHEN OKC_API.G_EXCEPTION_ERROR THEN
2267: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2268: (l_api_name
2269: ,G_PKG_NAME
2270: ,'OKC_API.G_RET_STS_ERROR'

Line 2267: x_return_status := OKC_API.HANDLE_EXCEPTIONS

2263:
2264:
2265: EXCEPTION
2266: WHEN OKC_API.G_EXCEPTION_ERROR THEN
2267: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2268: (l_api_name
2269: ,G_PKG_NAME
2270: ,'OKC_API.G_RET_STS_ERROR'
2271: ,x_msg_count

Line 2270: ,'OKC_API.G_RET_STS_ERROR'

2266: WHEN OKC_API.G_EXCEPTION_ERROR THEN
2267: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2268: (l_api_name
2269: ,G_PKG_NAME
2270: ,'OKC_API.G_RET_STS_ERROR'
2271: ,x_msg_count
2272: ,x_msg_data
2273: ,'_PUB');
2274:

Line 2278: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

2274:
2275:
2276:
2277:
2278: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
2279: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
2280: (l_api_name
2281: ,G_PKG_NAME
2282: ,'OKC_API.G_RET_STS_UNEXP_ERROR'

Line 2279: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

2275:
2276:
2277:
2278: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
2279: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
2280: (l_api_name
2281: ,G_PKG_NAME
2282: ,'OKC_API.G_RET_STS_UNEXP_ERROR'
2283: ,x_msg_count

Line 2282: ,'OKC_API.G_RET_STS_UNEXP_ERROR'

2278: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
2279: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
2280: (l_api_name
2281: ,G_PKG_NAME
2282: ,'OKC_API.G_RET_STS_UNEXP_ERROR'
2283: ,x_msg_count
2284: ,x_msg_data
2285: ,'_PUB');
2286:

Line 2291: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

2287:
2288:
2289:
2290: WHEN OTHERS THEN
2291: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
2292: (l_api_name
2293: ,G_PKG_NAME
2294: ,'OTHERS'
2295: ,x_msg_count

Line 2316: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;

2312: x_msg_data OUT NOCOPY VARCHAR2,
2313: p_rmpv_tbl IN rmpv_tbl_type,
2314: x_rmpv_tbl OUT NOCOPY rmpv_tbl_type) IS
2315: i NUMBER := 0;
2316: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2317: --
2318: l_proc varchar2(72) := g_package||'update_rg_mode_pty_role';
2319: --
2320:

Line 2326: x_return_status := OKC_API.G_RET_STS_SUCCESS;

2322:
2323:
2324:
2325:
2326: x_return_status := OKC_API.G_RET_STS_SUCCESS;
2327: IF p_rmpv_tbl.COUNT > 0 THEN
2328: i := p_rmpv_tbl.FIRST;
2329: LOOP
2330: update_rg_mode_pty_role(

Line 2338: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN

2334: x_msg_count => x_msg_count,
2335: x_msg_data => x_msg_data,
2336: p_rmpv_rec => p_rmpv_tbl(i),
2337: x_rmpv_rec => x_rmpv_tbl(i));
2338: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2339: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2340: x_return_status := l_return_status;
2341: raise G_EXCEPTION_HALT_VALIDATION;
2342: ELSE

Line 2339: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

2335: x_msg_data => x_msg_data,
2336: p_rmpv_rec => p_rmpv_tbl(i),
2337: x_rmpv_rec => x_rmpv_tbl(i));
2338: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2339: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2340: x_return_status := l_return_status;
2341: raise G_EXCEPTION_HALT_VALIDATION;
2342: ELSE
2343: x_return_status := l_return_status;

Line 2363: OKC_API.SET_MESSAGE(

2359:
2360: NULL;
2361: WHEN OTHERS THEN
2362: -- store SQL error message on message stack
2363: OKC_API.SET_MESSAGE(
2364: p_app_name => G_APP_NAME,
2365: p_msg_name => G_UNEXPECTED_ERROR,
2366: p_token1 => G_SQLCODE_TOKEN,
2367: p_token1_value => SQLCODE,

Line 2371: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

2367: p_token1_value => SQLCODE,
2368: p_token2 => G_SQLERRM_TOKEN,
2369: p_token2_value => SQLERRM);
2370: -- notify caller of an error as UNEXPETED error
2371: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
2372:
2373:
2374:
2375:

Line 2388: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;

2384: x_return_status OUT NOCOPY VARCHAR2,
2385: x_msg_count OUT NOCOPY NUMBER,
2386: x_msg_data OUT NOCOPY VARCHAR2,
2387: p_rmpv_rec IN rmpv_rec_type) IS
2388: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2389: l_api_name CONSTANT VARCHAR2(30) := 'delete_rg_mode_pty_role';
2390: l_rmpv_rec rmpv_rec_type := p_rmpv_rec;
2391: --
2392: l_proc varchar2(72) := g_package||'delete_rg_mode_pty_role';

Line 2400: l_return_status := OKC_API.START_ACTIVITY(l_api_name,

2396:
2397:
2398:
2399:
2400: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
2401: p_init_msg_list,
2402: '_PUB',
2403: x_return_status);
2404: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

Line 2404: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

2400: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
2401: p_init_msg_list,
2402: '_PUB',
2403: x_return_status);
2404: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2405: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2406: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2407: raise OKC_API.G_EXCEPTION_ERROR;
2408: END IF;

Line 2405: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2401: p_init_msg_list,
2402: '_PUB',
2403: x_return_status);
2404: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2405: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2406: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2407: raise OKC_API.G_EXCEPTION_ERROR;
2408: END IF;
2409: -- Call user hook for BEFORE

Line 2406: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN

2402: '_PUB',
2403: x_return_status);
2404: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2405: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2406: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2407: raise OKC_API.G_EXCEPTION_ERROR;
2408: END IF;
2409: -- Call user hook for BEFORE
2410: g_rmpv_rec := p_rmpv_rec;

Line 2407: raise OKC_API.G_EXCEPTION_ERROR;

2403: x_return_status);
2404: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2405: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2406: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2407: raise OKC_API.G_EXCEPTION_ERROR;
2408: END IF;
2409: -- Call user hook for BEFORE
2410: g_rmpv_rec := p_rmpv_rec;
2411: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');

Line 2412: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

2408: END IF;
2409: -- Call user hook for BEFORE
2410: g_rmpv_rec := p_rmpv_rec;
2411: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
2412: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2413: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2414: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2415: raise OKC_API.G_EXCEPTION_ERROR;
2416: END IF;

Line 2413: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2409: -- Call user hook for BEFORE
2410: g_rmpv_rec := p_rmpv_rec;
2411: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
2412: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2413: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2414: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2415: raise OKC_API.G_EXCEPTION_ERROR;
2416: END IF;
2417:

Line 2414: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN

2410: g_rmpv_rec := p_rmpv_rec;
2411: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
2412: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2413: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2414: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2415: raise OKC_API.G_EXCEPTION_ERROR;
2416: END IF;
2417:
2418: OKC_RULE_PVT.delete_rg_mode_pty_role(

Line 2415: raise OKC_API.G_EXCEPTION_ERROR;

2411: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
2412: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2413: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2414: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2415: raise OKC_API.G_EXCEPTION_ERROR;
2416: END IF;
2417:
2418: OKC_RULE_PVT.delete_rg_mode_pty_role(
2419: p_api_version => p_api_version,

Line 2426: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

2422: x_msg_count => x_msg_count,
2423: x_msg_data => x_msg_data,
2424: p_rmpv_rec => p_rmpv_rec);
2425:
2426: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2427: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2428: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2429: raise OKC_API.G_EXCEPTION_ERROR;
2430: END IF;

Line 2427: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2423: x_msg_data => x_msg_data,
2424: p_rmpv_rec => p_rmpv_rec);
2425:
2426: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2427: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2428: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2429: raise OKC_API.G_EXCEPTION_ERROR;
2430: END IF;
2431:

Line 2428: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN

2424: p_rmpv_rec => p_rmpv_rec);
2425:
2426: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2427: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2428: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2429: raise OKC_API.G_EXCEPTION_ERROR;
2430: END IF;
2431:
2432: -- Call user hook for AFTER

Line 2429: raise OKC_API.G_EXCEPTION_ERROR;

2425:
2426: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2427: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2428: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2429: raise OKC_API.G_EXCEPTION_ERROR;
2430: END IF;
2431:
2432: -- Call user hook for AFTER
2433: g_rmpv_rec := l_rmpv_rec;

Line 2435: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

2431:
2432: -- Call user hook for AFTER
2433: g_rmpv_rec := l_rmpv_rec;
2434: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
2435: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2436: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2437: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2438: raise OKC_API.G_EXCEPTION_ERROR;
2439: END IF;

Line 2436: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2432: -- Call user hook for AFTER
2433: g_rmpv_rec := l_rmpv_rec;
2434: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
2435: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2436: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2437: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2438: raise OKC_API.G_EXCEPTION_ERROR;
2439: END IF;
2440: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

Line 2437: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN

2433: g_rmpv_rec := l_rmpv_rec;
2434: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
2435: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2436: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2437: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2438: raise OKC_API.G_EXCEPTION_ERROR;
2439: END IF;
2440: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
2441:

Line 2438: raise OKC_API.G_EXCEPTION_ERROR;

2434: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
2435: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2436: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2437: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2438: raise OKC_API.G_EXCEPTION_ERROR;
2439: END IF;
2440: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
2441:
2442:

Line 2440: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

2436: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2437: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2438: raise OKC_API.G_EXCEPTION_ERROR;
2439: END IF;
2440: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
2441:
2442:
2443:
2444:

Line 2446: WHEN OKC_API.G_EXCEPTION_ERROR THEN

2442:
2443:
2444:
2445: EXCEPTION
2446: WHEN OKC_API.G_EXCEPTION_ERROR THEN
2447: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2448: (l_api_name
2449: ,G_PKG_NAME
2450: ,'OKC_API.G_RET_STS_ERROR'

Line 2447: x_return_status := OKC_API.HANDLE_EXCEPTIONS

2443:
2444:
2445: EXCEPTION
2446: WHEN OKC_API.G_EXCEPTION_ERROR THEN
2447: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2448: (l_api_name
2449: ,G_PKG_NAME
2450: ,'OKC_API.G_RET_STS_ERROR'
2451: ,x_msg_count

Line 2450: ,'OKC_API.G_RET_STS_ERROR'

2446: WHEN OKC_API.G_EXCEPTION_ERROR THEN
2447: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2448: (l_api_name
2449: ,G_PKG_NAME
2450: ,'OKC_API.G_RET_STS_ERROR'
2451: ,x_msg_count
2452: ,x_msg_data
2453: ,'_PUB');
2454:

Line 2458: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

2454:
2455:
2456:
2457:
2458: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
2459: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
2460: (l_api_name
2461: ,G_PKG_NAME
2462: ,'OKC_API.G_RET_STS_UNEXP_ERROR'

Line 2459: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

2455:
2456:
2457:
2458: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
2459: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
2460: (l_api_name
2461: ,G_PKG_NAME
2462: ,'OKC_API.G_RET_STS_UNEXP_ERROR'
2463: ,x_msg_count

Line 2462: ,'OKC_API.G_RET_STS_UNEXP_ERROR'

2458: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
2459: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
2460: (l_api_name
2461: ,G_PKG_NAME
2462: ,'OKC_API.G_RET_STS_UNEXP_ERROR'
2463: ,x_msg_count
2464: ,x_msg_data
2465: ,'_PUB');
2466:

Line 2471: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

2467:
2468:
2469:
2470: WHEN OTHERS THEN
2471: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
2472: (l_api_name
2473: ,G_PKG_NAME
2474: ,'OTHERS'
2475: ,x_msg_count

Line 2495: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;

2491: x_msg_count OUT NOCOPY NUMBER,
2492: x_msg_data OUT NOCOPY VARCHAR2,
2493: p_rmpv_tbl IN rmpv_tbl_type) IS
2494: i NUMBER := 0;
2495: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2496: --
2497: l_proc varchar2(72) := g_package||'delete_rg_mode_pty_role';
2498: --
2499:

Line 2505: x_return_status := OKC_API.G_RET_STS_SUCCESS;

2501:
2502:
2503:
2504:
2505: x_return_status := OKC_API.G_RET_STS_SUCCESS;
2506: IF p_rmpv_tbl.COUNT > 0 THEN
2507: i := p_rmpv_tbl.FIRST;
2508: LOOP
2509: delete_rg_mode_pty_role(

Line 2516: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN

2512: x_return_status => l_return_status,
2513: x_msg_count => x_msg_count,
2514: x_msg_data => x_msg_data,
2515: p_rmpv_rec => p_rmpv_tbl(i));
2516: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2517: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2518: x_return_status := l_return_status;
2519: raise G_EXCEPTION_HALT_VALIDATION;
2520: ELSE

Line 2517: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

2513: x_msg_count => x_msg_count,
2514: x_msg_data => x_msg_data,
2515: p_rmpv_rec => p_rmpv_tbl(i));
2516: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2517: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2518: x_return_status := l_return_status;
2519: raise G_EXCEPTION_HALT_VALIDATION;
2520: ELSE
2521: x_return_status := l_return_status;

Line 2541: OKC_API.SET_MESSAGE(

2537:
2538: NULL;
2539: WHEN OTHERS THEN
2540: -- store SQL error message on message stack
2541: OKC_API.SET_MESSAGE(
2542: p_app_name => G_APP_NAME,
2543: p_msg_name => G_UNEXPECTED_ERROR,
2544: p_token1 => G_SQLCODE_TOKEN,
2545: p_token1_value => SQLCODE,

Line 2549: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

2545: p_token1_value => SQLCODE,
2546: p_token2 => G_SQLERRM_TOKEN,
2547: p_token2_value => SQLERRM);
2548: -- notify caller of an error as UNEXPETED error
2549: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
2550:
2551:
2552:
2553:

Line 2595: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;

2591: x_msg_count OUT NOCOPY NUMBER,
2592: x_msg_data OUT NOCOPY VARCHAR2,
2593: p_rmpv_tbl IN rmpv_tbl_type) IS
2594: i NUMBER := 0;
2595: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2596: --
2597: l_proc varchar2(72) := g_package||'lock_rg_mode_pty_role';
2598: --
2599:

Line 2605: x_return_status := OKC_API.G_RET_STS_SUCCESS;

2601:
2602:
2603:
2604:
2605: x_return_status := OKC_API.G_RET_STS_SUCCESS;
2606: IF p_rmpv_tbl.COUNT > 0 THEN
2607: i := p_rmpv_tbl.FIRST;
2608: LOOP
2609: lock_rg_mode_pty_role(

Line 2616: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN

2612: x_return_status => l_return_status,
2613: x_msg_count => x_msg_count,
2614: x_msg_data => x_msg_data,
2615: p_rmpv_rec => p_rmpv_tbl(i));
2616: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2617: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2618: x_return_status := l_return_status;
2619: raise G_EXCEPTION_HALT_VALIDATION;
2620: ELSE

Line 2617: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

2613: x_msg_count => x_msg_count,
2614: x_msg_data => x_msg_data,
2615: p_rmpv_rec => p_rmpv_tbl(i));
2616: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2617: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2618: x_return_status := l_return_status;
2619: raise G_EXCEPTION_HALT_VALIDATION;
2620: ELSE
2621: x_return_status := l_return_status;

Line 2641: OKC_API.SET_MESSAGE(

2637:
2638: NULL;
2639: WHEN OTHERS THEN
2640: -- store SQL error message on message stack
2641: OKC_API.SET_MESSAGE(
2642: p_app_name => G_APP_NAME,
2643: p_msg_name => G_UNEXPECTED_ERROR,
2644: p_token1 => G_SQLCODE_TOKEN,
2645: p_token1_value => SQLCODE,

Line 2649: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

2645: p_token1_value => SQLCODE,
2646: p_token2 => G_SQLERRM_TOKEN,
2647: p_token2_value => SQLERRM);
2648: -- notify caller of an error as UNEXPETED error
2649: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
2650:
2651:
2652:
2653:

Line 2666: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;

2662: x_return_status OUT NOCOPY VARCHAR2,
2663: x_msg_count OUT NOCOPY NUMBER,
2664: x_msg_data OUT NOCOPY VARCHAR2,
2665: p_rmpv_rec IN rmpv_rec_type) IS
2666: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2667: l_api_name CONSTANT VARCHAR2(30) := 'validate_rg_mode_pty_role';
2668: l_rmpv_rec rmpv_rec_type := p_rmpv_rec;
2669: --
2670: l_proc varchar2(72) := g_package||'validate_rg_mode_pty_role';

Line 2678: l_return_status := OKC_API.START_ACTIVITY(l_api_name,

2674:
2675:
2676:
2677:
2678: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
2679: p_init_msg_list,
2680: '_PUB',
2681: x_return_status);
2682: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

Line 2682: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

2678: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
2679: p_init_msg_list,
2680: '_PUB',
2681: x_return_status);
2682: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2683: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2684: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2685: raise OKC_API.G_EXCEPTION_ERROR;
2686: END IF;

Line 2683: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2679: p_init_msg_list,
2680: '_PUB',
2681: x_return_status);
2682: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2683: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2684: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2685: raise OKC_API.G_EXCEPTION_ERROR;
2686: END IF;
2687: -- Call user hook for BEFORE

Line 2684: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN

2680: '_PUB',
2681: x_return_status);
2682: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2683: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2684: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2685: raise OKC_API.G_EXCEPTION_ERROR;
2686: END IF;
2687: -- Call user hook for BEFORE
2688: g_rmpv_rec := p_rmpv_rec;

Line 2685: raise OKC_API.G_EXCEPTION_ERROR;

2681: x_return_status);
2682: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2683: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2684: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2685: raise OKC_API.G_EXCEPTION_ERROR;
2686: END IF;
2687: -- Call user hook for BEFORE
2688: g_rmpv_rec := p_rmpv_rec;
2689: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');

Line 2690: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

2686: END IF;
2687: -- Call user hook for BEFORE
2688: g_rmpv_rec := p_rmpv_rec;
2689: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
2690: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2691: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2692: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2693: raise OKC_API.G_EXCEPTION_ERROR;
2694: END IF;

Line 2691: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2687: -- Call user hook for BEFORE
2688: g_rmpv_rec := p_rmpv_rec;
2689: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
2690: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2691: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2692: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2693: raise OKC_API.G_EXCEPTION_ERROR;
2694: END IF;
2695:

Line 2692: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN

2688: g_rmpv_rec := p_rmpv_rec;
2689: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
2690: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2691: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2692: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2693: raise OKC_API.G_EXCEPTION_ERROR;
2694: END IF;
2695:
2696: OKC_RULE_PVT.validate_rg_mode_pty_role(

Line 2693: raise OKC_API.G_EXCEPTION_ERROR;

2689: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
2690: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2691: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2692: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2693: raise OKC_API.G_EXCEPTION_ERROR;
2694: END IF;
2695:
2696: OKC_RULE_PVT.validate_rg_mode_pty_role(
2697: p_api_version => p_api_version,

Line 2704: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

2700: x_msg_count => x_msg_count,
2701: x_msg_data => x_msg_data,
2702: p_rmpv_rec => p_rmpv_rec);
2703:
2704: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2705: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2706: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2707: raise OKC_API.G_EXCEPTION_ERROR;
2708: END IF;

Line 2705: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2701: x_msg_data => x_msg_data,
2702: p_rmpv_rec => p_rmpv_rec);
2703:
2704: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2705: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2706: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2707: raise OKC_API.G_EXCEPTION_ERROR;
2708: END IF;
2709:

Line 2706: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN

2702: p_rmpv_rec => p_rmpv_rec);
2703:
2704: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2705: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2706: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2707: raise OKC_API.G_EXCEPTION_ERROR;
2708: END IF;
2709:
2710: -- Call user hook for AFTER

Line 2707: raise OKC_API.G_EXCEPTION_ERROR;

2703:
2704: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2705: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2706: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2707: raise OKC_API.G_EXCEPTION_ERROR;
2708: END IF;
2709:
2710: -- Call user hook for AFTER
2711: g_rmpv_rec := l_rmpv_rec;

Line 2713: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

2709:
2710: -- Call user hook for AFTER
2711: g_rmpv_rec := l_rmpv_rec;
2712: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
2713: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2714: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2715: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2716: raise OKC_API.G_EXCEPTION_ERROR;
2717: END IF;

Line 2714: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2710: -- Call user hook for AFTER
2711: g_rmpv_rec := l_rmpv_rec;
2712: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
2713: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2714: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2715: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2716: raise OKC_API.G_EXCEPTION_ERROR;
2717: END IF;
2718: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

Line 2715: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN

2711: g_rmpv_rec := l_rmpv_rec;
2712: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
2713: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2714: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2715: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2716: raise OKC_API.G_EXCEPTION_ERROR;
2717: END IF;
2718: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
2719:

Line 2716: raise OKC_API.G_EXCEPTION_ERROR;

2712: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
2713: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2714: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2715: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2716: raise OKC_API.G_EXCEPTION_ERROR;
2717: END IF;
2718: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
2719:
2720:

Line 2718: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

2714: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2715: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2716: raise OKC_API.G_EXCEPTION_ERROR;
2717: END IF;
2718: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
2719:
2720:
2721:
2722:

Line 2724: WHEN OKC_API.G_EXCEPTION_ERROR THEN

2720:
2721:
2722:
2723: EXCEPTION
2724: WHEN OKC_API.G_EXCEPTION_ERROR THEN
2725: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2726: (l_api_name
2727: ,G_PKG_NAME
2728: ,'OKC_API.G_RET_STS_ERROR'

Line 2725: x_return_status := OKC_API.HANDLE_EXCEPTIONS

2721:
2722:
2723: EXCEPTION
2724: WHEN OKC_API.G_EXCEPTION_ERROR THEN
2725: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2726: (l_api_name
2727: ,G_PKG_NAME
2728: ,'OKC_API.G_RET_STS_ERROR'
2729: ,x_msg_count

Line 2728: ,'OKC_API.G_RET_STS_ERROR'

2724: WHEN OKC_API.G_EXCEPTION_ERROR THEN
2725: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2726: (l_api_name
2727: ,G_PKG_NAME
2728: ,'OKC_API.G_RET_STS_ERROR'
2729: ,x_msg_count
2730: ,x_msg_data
2731: ,'_PUB');
2732:

Line 2736: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

2732:
2733:
2734:
2735:
2736: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
2737: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
2738: (l_api_name
2739: ,G_PKG_NAME
2740: ,'OKC_API.G_RET_STS_UNEXP_ERROR'

Line 2737: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

2733:
2734:
2735:
2736: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
2737: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
2738: (l_api_name
2739: ,G_PKG_NAME
2740: ,'OKC_API.G_RET_STS_UNEXP_ERROR'
2741: ,x_msg_count

Line 2740: ,'OKC_API.G_RET_STS_UNEXP_ERROR'

2736: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
2737: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
2738: (l_api_name
2739: ,G_PKG_NAME
2740: ,'OKC_API.G_RET_STS_UNEXP_ERROR'
2741: ,x_msg_count
2742: ,x_msg_data
2743: ,'_PUB');
2744:

Line 2749: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

2745:
2746:
2747:
2748: WHEN OTHERS THEN
2749: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
2750: (l_api_name
2751: ,G_PKG_NAME
2752: ,'OTHERS'
2753: ,x_msg_count

Line 2773: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;

2769: x_msg_count OUT NOCOPY NUMBER,
2770: x_msg_data OUT NOCOPY VARCHAR2,
2771: p_rmpv_tbl IN rmpv_tbl_type) IS
2772: i NUMBER := 0;
2773: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2774: --
2775: l_proc varchar2(72) := g_package||'validate_rg_mode_pty_role';
2776: --
2777:

Line 2783: x_return_status := OKC_API.G_RET_STS_SUCCESS;

2779:
2780:
2781:
2782:
2783: x_return_status := OKC_API.G_RET_STS_SUCCESS;
2784: IF p_rmpv_tbl.COUNT > 0 THEN
2785: i := p_rmpv_tbl.FIRST;
2786: LOOP
2787: validate_rg_mode_pty_role(

Line 2794: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN

2790: x_return_status => l_return_status,
2791: x_msg_count => x_msg_count,
2792: x_msg_data => x_msg_data,
2793: p_rmpv_rec => p_rmpv_tbl(i));
2794: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2795: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2796: x_return_status := l_return_status;
2797: raise G_EXCEPTION_HALT_VALIDATION;
2798: ELSE

Line 2795: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

2791: x_msg_count => x_msg_count,
2792: x_msg_data => x_msg_data,
2793: p_rmpv_rec => p_rmpv_tbl(i));
2794: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2795: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2796: x_return_status := l_return_status;
2797: raise G_EXCEPTION_HALT_VALIDATION;
2798: ELSE
2799: x_return_status := l_return_status;

Line 2819: OKC_API.SET_MESSAGE(

2815:
2816: NULL;
2817: WHEN OTHERS THEN
2818: -- store SQL error message on message stack
2819: OKC_API.SET_MESSAGE(
2820: p_app_name => G_APP_NAME,
2821: p_msg_name => G_UNEXPECTED_ERROR,
2822: p_token1 => G_SQLCODE_TOKEN,
2823: p_token1_value => SQLCODE,

Line 2827: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

2823: p_token1_value => SQLCODE,
2824: p_token2 => G_SQLERRM_TOKEN,
2825: p_token2_value => SQLERRM);
2826: -- notify caller of an error as UNEXPETED error
2827: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
2828:
2829:
2830:
2831:

Line 2879: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;

2875: x_msg_count OUT NOCOPY NUMBER,
2876: x_msg_data OUT NOCOPY VARCHAR2,
2877: p_ctiv_rec IN ctiv_rec_type,
2878: x_ctiv_rec OUT NOCOPY ctiv_rec_type) IS
2879: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2880: l_api_name CONSTANT VARCHAR2(30) := 'create_cover_time';
2881: l_ctiv_rec ctiv_rec_type := p_ctiv_rec;
2882: --
2883: l_proc varchar2(72) := g_package||'create_cover_time';

Line 2891: l_return_status := OKC_API.START_ACTIVITY(l_api_name,

2887:
2888:
2889:
2890:
2891: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
2892: p_init_msg_list,
2893: '_PUB',
2894: x_return_status);
2895: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

Line 2895: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

2891: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
2892: p_init_msg_list,
2893: '_PUB',
2894: x_return_status);
2895: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2896: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2897: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2898: raise OKC_API.G_EXCEPTION_ERROR;
2899: END IF;

Line 2896: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2892: p_init_msg_list,
2893: '_PUB',
2894: x_return_status);
2895: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2896: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2897: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2898: raise OKC_API.G_EXCEPTION_ERROR;
2899: END IF;
2900: -- Call user hook for BEFORE

Line 2897: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN

2893: '_PUB',
2894: x_return_status);
2895: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2896: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2897: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2898: raise OKC_API.G_EXCEPTION_ERROR;
2899: END IF;
2900: -- Call user hook for BEFORE
2901: g_ctiv_rec := p_ctiv_rec;

Line 2898: raise OKC_API.G_EXCEPTION_ERROR;

2894: x_return_status);
2895: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2896: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2897: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2898: raise OKC_API.G_EXCEPTION_ERROR;
2899: END IF;
2900: -- Call user hook for BEFORE
2901: g_ctiv_rec := p_ctiv_rec;
2902: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');

Line 2903: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

2899: END IF;
2900: -- Call user hook for BEFORE
2901: g_ctiv_rec := p_ctiv_rec;
2902: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
2903: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2904: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2905: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2906: raise OKC_API.G_EXCEPTION_ERROR;
2907: END IF;

Line 2904: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2900: -- Call user hook for BEFORE
2901: g_ctiv_rec := p_ctiv_rec;
2902: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
2903: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2904: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2905: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2906: raise OKC_API.G_EXCEPTION_ERROR;
2907: END IF;
2908: l_ctiv_rec := migrate_ctiv(l_ctiv_rec, g_ctiv_rec);

Line 2905: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN

2901: g_ctiv_rec := p_ctiv_rec;
2902: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
2903: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2904: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2905: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2906: raise OKC_API.G_EXCEPTION_ERROR;
2907: END IF;
2908: l_ctiv_rec := migrate_ctiv(l_ctiv_rec, g_ctiv_rec);
2909:

Line 2906: raise OKC_API.G_EXCEPTION_ERROR;

2902: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
2903: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2904: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2905: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2906: raise OKC_API.G_EXCEPTION_ERROR;
2907: END IF;
2908: l_ctiv_rec := migrate_ctiv(l_ctiv_rec, g_ctiv_rec);
2909:
2910: OKC_RULE_PVT.create_cover_time(

Line 2919: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

2915: x_msg_data => x_msg_data,
2916: p_ctiv_rec => l_ctiv_rec,
2917: x_ctiv_rec => x_ctiv_rec);
2918:
2919: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2920: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2921: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2922: raise OKC_API.G_EXCEPTION_ERROR;
2923: END IF;

Line 2920: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2916: p_ctiv_rec => l_ctiv_rec,
2917: x_ctiv_rec => x_ctiv_rec);
2918:
2919: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2920: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2921: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2922: raise OKC_API.G_EXCEPTION_ERROR;
2923: END IF;
2924:

Line 2921: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN

2917: x_ctiv_rec => x_ctiv_rec);
2918:
2919: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2920: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2921: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2922: raise OKC_API.G_EXCEPTION_ERROR;
2923: END IF;
2924:
2925: -- Call user hook for AFTER

Line 2922: raise OKC_API.G_EXCEPTION_ERROR;

2918:
2919: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2920: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2921: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2922: raise OKC_API.G_EXCEPTION_ERROR;
2923: END IF;
2924:
2925: -- Call user hook for AFTER
2926: g_ctiv_rec := x_ctiv_rec;

Line 2928: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

2924:
2925: -- Call user hook for AFTER
2926: g_ctiv_rec := x_ctiv_rec;
2927: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
2928: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2929: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2930: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2931: raise OKC_API.G_EXCEPTION_ERROR;
2932: END IF;

Line 2929: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2925: -- Call user hook for AFTER
2926: g_ctiv_rec := x_ctiv_rec;
2927: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
2928: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2929: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2930: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2931: raise OKC_API.G_EXCEPTION_ERROR;
2932: END IF;
2933: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

Line 2930: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN

2926: g_ctiv_rec := x_ctiv_rec;
2927: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
2928: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2929: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2930: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2931: raise OKC_API.G_EXCEPTION_ERROR;
2932: END IF;
2933: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
2934:

Line 2931: raise OKC_API.G_EXCEPTION_ERROR;

2927: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
2928: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2929: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2930: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2931: raise OKC_API.G_EXCEPTION_ERROR;
2932: END IF;
2933: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
2934:
2935:

Line 2933: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

2929: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2930: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2931: raise OKC_API.G_EXCEPTION_ERROR;
2932: END IF;
2933: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
2934:
2935:
2936:
2937:

Line 2939: WHEN OKC_API.G_EXCEPTION_ERROR THEN

2935:
2936:
2937:
2938: EXCEPTION
2939: WHEN OKC_API.G_EXCEPTION_ERROR THEN
2940: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2941: (l_api_name
2942: ,G_PKG_NAME
2943: ,'OKC_API.G_RET_STS_ERROR'

Line 2940: x_return_status := OKC_API.HANDLE_EXCEPTIONS

2936:
2937:
2938: EXCEPTION
2939: WHEN OKC_API.G_EXCEPTION_ERROR THEN
2940: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2941: (l_api_name
2942: ,G_PKG_NAME
2943: ,'OKC_API.G_RET_STS_ERROR'
2944: ,x_msg_count

Line 2943: ,'OKC_API.G_RET_STS_ERROR'

2939: WHEN OKC_API.G_EXCEPTION_ERROR THEN
2940: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2941: (l_api_name
2942: ,G_PKG_NAME
2943: ,'OKC_API.G_RET_STS_ERROR'
2944: ,x_msg_count
2945: ,x_msg_data
2946: ,'_PUB');
2947:

Line 2951: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

2947:
2948:
2949:
2950:
2951: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
2952: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
2953: (l_api_name
2954: ,G_PKG_NAME
2955: ,'OKC_API.G_RET_STS_UNEXP_ERROR'

Line 2952: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

2948:
2949:
2950:
2951: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
2952: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
2953: (l_api_name
2954: ,G_PKG_NAME
2955: ,'OKC_API.G_RET_STS_UNEXP_ERROR'
2956: ,x_msg_count

Line 2955: ,'OKC_API.G_RET_STS_UNEXP_ERROR'

2951: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
2952: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
2953: (l_api_name
2954: ,G_PKG_NAME
2955: ,'OKC_API.G_RET_STS_UNEXP_ERROR'
2956: ,x_msg_count
2957: ,x_msg_data
2958: ,'_PUB');
2959:

Line 2964: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

2960:
2961:
2962:
2963: WHEN OTHERS THEN
2964: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
2965: (l_api_name
2966: ,G_PKG_NAME
2967: ,'OTHERS'
2968: ,x_msg_count

Line 2989: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;

2985: x_msg_data OUT NOCOPY VARCHAR2,
2986: p_ctiv_tbl IN ctiv_tbl_type,
2987: x_ctiv_tbl OUT NOCOPY ctiv_tbl_type) IS
2988: i NUMBER := 0;
2989: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2990: --
2991: l_proc varchar2(72) := g_package||'create_cover_time';
2992: --
2993:

Line 2999: x_return_status := OKC_API.G_RET_STS_SUCCESS;

2995:
2996:
2997:
2998:
2999: x_return_status := OKC_API.G_RET_STS_SUCCESS;
3000: IF p_ctiv_tbl.COUNT > 0 THEN
3001: i := p_ctiv_tbl.FIRST;
3002: LOOP
3003: create_cover_time(

Line 3011: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN

3007: x_msg_count => x_msg_count,
3008: x_msg_data => x_msg_data,
3009: p_ctiv_rec => p_ctiv_tbl(i),
3010: x_ctiv_rec => x_ctiv_tbl(i));
3011: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
3012: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3013: x_return_status := l_return_status;
3014: raise G_EXCEPTION_HALT_VALIDATION;
3015: ELSE

Line 3012: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

3008: x_msg_data => x_msg_data,
3009: p_ctiv_rec => p_ctiv_tbl(i),
3010: x_ctiv_rec => x_ctiv_tbl(i));
3011: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
3012: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3013: x_return_status := l_return_status;
3014: raise G_EXCEPTION_HALT_VALIDATION;
3015: ELSE
3016: x_return_status := l_return_status;

Line 3036: OKC_API.SET_MESSAGE(

3032:
3033: NULL;
3034: WHEN OTHERS THEN
3035: -- store SQL error message on message stack
3036: OKC_API.SET_MESSAGE(
3037: p_app_name => G_APP_NAME,
3038: p_msg_name => G_UNEXPECTED_ERROR,
3039: p_token1 => G_SQLCODE_TOKEN,
3040: p_token1_value => SQLCODE,

Line 3044: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

3040: p_token1_value => SQLCODE,
3041: p_token2 => G_SQLERRM_TOKEN,
3042: p_token2_value => SQLERRM);
3043: -- notify caller of an error as UNEXPETED error
3044: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
3045:
3046:
3047:
3048:

Line 3062: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;

3058: x_msg_count OUT NOCOPY NUMBER,
3059: x_msg_data OUT NOCOPY VARCHAR2,
3060: p_ctiv_rec IN ctiv_rec_type,
3061: x_ctiv_rec OUT NOCOPY ctiv_rec_type) IS
3062: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
3063: l_api_name CONSTANT VARCHAR2(30) := 'update_cover_time';
3064: l_ctiv_rec ctiv_rec_type := p_ctiv_rec;
3065: --
3066: l_proc varchar2(72) := g_package||'update_cover_time';

Line 3074: l_return_status := OKC_API.START_ACTIVITY(l_api_name,

3070:
3071:
3072:
3073:
3074: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
3075: p_init_msg_list,
3076: '_PUB',
3077: x_return_status);
3078: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

Line 3078: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

3074: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
3075: p_init_msg_list,
3076: '_PUB',
3077: x_return_status);
3078: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3079: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3080: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
3081: raise OKC_API.G_EXCEPTION_ERROR;
3082: END IF;

Line 3079: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

3075: p_init_msg_list,
3076: '_PUB',
3077: x_return_status);
3078: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3079: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3080: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
3081: raise OKC_API.G_EXCEPTION_ERROR;
3082: END IF;
3083: -- Call user hook for BEFORE

Line 3080: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN

3076: '_PUB',
3077: x_return_status);
3078: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3079: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3080: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
3081: raise OKC_API.G_EXCEPTION_ERROR;
3082: END IF;
3083: -- Call user hook for BEFORE
3084: g_ctiv_rec := p_ctiv_rec;

Line 3081: raise OKC_API.G_EXCEPTION_ERROR;

3077: x_return_status);
3078: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3079: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3080: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
3081: raise OKC_API.G_EXCEPTION_ERROR;
3082: END IF;
3083: -- Call user hook for BEFORE
3084: g_ctiv_rec := p_ctiv_rec;
3085: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');

Line 3086: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

3082: END IF;
3083: -- Call user hook for BEFORE
3084: g_ctiv_rec := p_ctiv_rec;
3085: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
3086: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3087: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3088: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3089: raise OKC_API.G_EXCEPTION_ERROR;
3090: END IF;

Line 3087: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

3083: -- Call user hook for BEFORE
3084: g_ctiv_rec := p_ctiv_rec;
3085: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
3086: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3087: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3088: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3089: raise OKC_API.G_EXCEPTION_ERROR;
3090: END IF;
3091: l_ctiv_rec := migrate_ctiv(l_ctiv_rec, g_ctiv_rec);

Line 3088: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN

3084: g_ctiv_rec := p_ctiv_rec;
3085: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
3086: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3087: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3088: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3089: raise OKC_API.G_EXCEPTION_ERROR;
3090: END IF;
3091: l_ctiv_rec := migrate_ctiv(l_ctiv_rec, g_ctiv_rec);
3092:

Line 3089: raise OKC_API.G_EXCEPTION_ERROR;

3085: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
3086: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3087: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3088: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3089: raise OKC_API.G_EXCEPTION_ERROR;
3090: END IF;
3091: l_ctiv_rec := migrate_ctiv(l_ctiv_rec, g_ctiv_rec);
3092:
3093: OKC_RULE_PVT.update_cover_time(

Line 3102: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

3098: x_msg_data => x_msg_data,
3099: p_ctiv_rec => l_ctiv_rec,
3100: x_ctiv_rec => x_ctiv_rec);
3101:
3102: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3103: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3104: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3105: raise OKC_API.G_EXCEPTION_ERROR;
3106: END IF;

Line 3103: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

3099: p_ctiv_rec => l_ctiv_rec,
3100: x_ctiv_rec => x_ctiv_rec);
3101:
3102: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3103: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3104: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3105: raise OKC_API.G_EXCEPTION_ERROR;
3106: END IF;
3107:

Line 3104: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN

3100: x_ctiv_rec => x_ctiv_rec);
3101:
3102: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3103: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3104: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3105: raise OKC_API.G_EXCEPTION_ERROR;
3106: END IF;
3107:
3108: -- Call user hook for AFTER

Line 3105: raise OKC_API.G_EXCEPTION_ERROR;

3101:
3102: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3103: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3104: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3105: raise OKC_API.G_EXCEPTION_ERROR;
3106: END IF;
3107:
3108: -- Call user hook for AFTER
3109: g_ctiv_rec := x_ctiv_rec;

Line 3111: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

3107:
3108: -- Call user hook for AFTER
3109: g_ctiv_rec := x_ctiv_rec;
3110: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
3111: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3112: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3113: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3114: raise OKC_API.G_EXCEPTION_ERROR;
3115: END IF;

Line 3112: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

3108: -- Call user hook for AFTER
3109: g_ctiv_rec := x_ctiv_rec;
3110: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
3111: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3112: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3113: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3114: raise OKC_API.G_EXCEPTION_ERROR;
3115: END IF;
3116: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

Line 3113: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN

3109: g_ctiv_rec := x_ctiv_rec;
3110: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
3111: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3112: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3113: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3114: raise OKC_API.G_EXCEPTION_ERROR;
3115: END IF;
3116: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
3117:

Line 3114: raise OKC_API.G_EXCEPTION_ERROR;

3110: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
3111: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3112: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3113: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3114: raise OKC_API.G_EXCEPTION_ERROR;
3115: END IF;
3116: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
3117:
3118:

Line 3116: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

3112: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3113: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3114: raise OKC_API.G_EXCEPTION_ERROR;
3115: END IF;
3116: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
3117:
3118:
3119:
3120:

Line 3122: WHEN OKC_API.G_EXCEPTION_ERROR THEN

3118:
3119:
3120:
3121: EXCEPTION
3122: WHEN OKC_API.G_EXCEPTION_ERROR THEN
3123: x_return_status := OKC_API.HANDLE_EXCEPTIONS
3124: (l_api_name
3125: ,G_PKG_NAME
3126: ,'OKC_API.G_RET_STS_ERROR'

Line 3123: x_return_status := OKC_API.HANDLE_EXCEPTIONS

3119:
3120:
3121: EXCEPTION
3122: WHEN OKC_API.G_EXCEPTION_ERROR THEN
3123: x_return_status := OKC_API.HANDLE_EXCEPTIONS
3124: (l_api_name
3125: ,G_PKG_NAME
3126: ,'OKC_API.G_RET_STS_ERROR'
3127: ,x_msg_count

Line 3126: ,'OKC_API.G_RET_STS_ERROR'

3122: WHEN OKC_API.G_EXCEPTION_ERROR THEN
3123: x_return_status := OKC_API.HANDLE_EXCEPTIONS
3124: (l_api_name
3125: ,G_PKG_NAME
3126: ,'OKC_API.G_RET_STS_ERROR'
3127: ,x_msg_count
3128: ,x_msg_data
3129: ,'_PUB');
3130:

Line 3134: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

3130:
3131:
3132:
3133:
3134: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
3135: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
3136: (l_api_name
3137: ,G_PKG_NAME
3138: ,'OKC_API.G_RET_STS_UNEXP_ERROR'

Line 3135: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

3131:
3132:
3133:
3134: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
3135: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
3136: (l_api_name
3137: ,G_PKG_NAME
3138: ,'OKC_API.G_RET_STS_UNEXP_ERROR'
3139: ,x_msg_count

Line 3138: ,'OKC_API.G_RET_STS_UNEXP_ERROR'

3134: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
3135: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
3136: (l_api_name
3137: ,G_PKG_NAME
3138: ,'OKC_API.G_RET_STS_UNEXP_ERROR'
3139: ,x_msg_count
3140: ,x_msg_data
3141: ,'_PUB');
3142:

Line 3147: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

3143:
3144:
3145:
3146: WHEN OTHERS THEN
3147: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
3148: (l_api_name
3149: ,G_PKG_NAME
3150: ,'OTHERS'
3151: ,x_msg_count

Line 3172: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;

3168: x_msg_data OUT NOCOPY VARCHAR2,
3169: p_ctiv_tbl IN ctiv_tbl_type,
3170: x_ctiv_tbl OUT NOCOPY ctiv_tbl_type) IS
3171: i NUMBER := 0;
3172: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
3173: --
3174: l_proc varchar2(72) := g_package||'update_cover_time';
3175: --
3176:

Line 3182: x_return_status := OKC_API.G_RET_STS_SUCCESS;

3178:
3179:
3180:
3181:
3182: x_return_status := OKC_API.G_RET_STS_SUCCESS;
3183: IF p_ctiv_tbl.COUNT > 0 THEN
3184: i := p_ctiv_tbl.FIRST;
3185: LOOP
3186: update_cover_time(

Line 3194: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN

3190: x_msg_count => x_msg_count,
3191: x_msg_data => x_msg_data,
3192: p_ctiv_rec => p_ctiv_tbl(i),
3193: x_ctiv_rec => x_ctiv_tbl(i));
3194: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
3195: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3196: x_return_status := l_return_status;
3197: raise G_EXCEPTION_HALT_VALIDATION;
3198: ELSE

Line 3195: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

3191: x_msg_data => x_msg_data,
3192: p_ctiv_rec => p_ctiv_tbl(i),
3193: x_ctiv_rec => x_ctiv_tbl(i));
3194: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
3195: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3196: x_return_status := l_return_status;
3197: raise G_EXCEPTION_HALT_VALIDATION;
3198: ELSE
3199: x_return_status := l_return_status;

Line 3219: OKC_API.SET_MESSAGE(

3215:
3216: NULL;
3217: WHEN OTHERS THEN
3218: -- store SQL error message on message stack
3219: OKC_API.SET_MESSAGE(
3220: p_app_name => G_APP_NAME,
3221: p_msg_name => G_UNEXPECTED_ERROR,
3222: p_token1 => G_SQLCODE_TOKEN,
3223: p_token1_value => SQLCODE,

Line 3227: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

3223: p_token1_value => SQLCODE,
3224: p_token2 => G_SQLERRM_TOKEN,
3225: p_token2_value => SQLERRM);
3226: -- notify caller of an error as UNEXPETED error
3227: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
3228:
3229:
3230:
3231:

Line 3244: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;

3240: x_return_status OUT NOCOPY VARCHAR2,
3241: x_msg_count OUT NOCOPY NUMBER,
3242: x_msg_data OUT NOCOPY VARCHAR2,
3243: p_ctiv_rec IN ctiv_rec_type) IS
3244: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
3245: l_api_name CONSTANT VARCHAR2(30) := 'delete_cover_time';
3246: l_ctiv_rec ctiv_rec_type := p_ctiv_rec;
3247: --
3248: l_proc varchar2(72) := g_package||'delete_cover_time';

Line 3256: l_return_status := OKC_API.START_ACTIVITY(l_api_name,

3252:
3253:
3254:
3255:
3256: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
3257: p_init_msg_list,
3258: '_PUB',
3259: x_return_status);
3260: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

Line 3260: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

3256: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
3257: p_init_msg_list,
3258: '_PUB',
3259: x_return_status);
3260: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3261: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3262: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
3263: raise OKC_API.G_EXCEPTION_ERROR;
3264: END IF;

Line 3261: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

3257: p_init_msg_list,
3258: '_PUB',
3259: x_return_status);
3260: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3261: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3262: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
3263: raise OKC_API.G_EXCEPTION_ERROR;
3264: END IF;
3265: -- Call user hook for BEFORE

Line 3262: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN

3258: '_PUB',
3259: x_return_status);
3260: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3261: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3262: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
3263: raise OKC_API.G_EXCEPTION_ERROR;
3264: END IF;
3265: -- Call user hook for BEFORE
3266: g_ctiv_rec := p_ctiv_rec;

Line 3263: raise OKC_API.G_EXCEPTION_ERROR;

3259: x_return_status);
3260: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3261: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3262: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
3263: raise OKC_API.G_EXCEPTION_ERROR;
3264: END IF;
3265: -- Call user hook for BEFORE
3266: g_ctiv_rec := p_ctiv_rec;
3267: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');

Line 3268: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

3264: END IF;
3265: -- Call user hook for BEFORE
3266: g_ctiv_rec := p_ctiv_rec;
3267: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
3268: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3269: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3270: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3271: raise OKC_API.G_EXCEPTION_ERROR;
3272: END IF;

Line 3269: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

3265: -- Call user hook for BEFORE
3266: g_ctiv_rec := p_ctiv_rec;
3267: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
3268: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3269: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3270: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3271: raise OKC_API.G_EXCEPTION_ERROR;
3272: END IF;
3273:

Line 3270: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN

3266: g_ctiv_rec := p_ctiv_rec;
3267: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
3268: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3269: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3270: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3271: raise OKC_API.G_EXCEPTION_ERROR;
3272: END IF;
3273:
3274: OKC_RULE_PVT.delete_cover_time(

Line 3271: raise OKC_API.G_EXCEPTION_ERROR;

3267: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
3268: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3269: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3270: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3271: raise OKC_API.G_EXCEPTION_ERROR;
3272: END IF;
3273:
3274: OKC_RULE_PVT.delete_cover_time(
3275: p_api_version => p_api_version,

Line 3282: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

3278: x_msg_count => x_msg_count,
3279: x_msg_data => x_msg_data,
3280: p_ctiv_rec => p_ctiv_rec);
3281:
3282: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3283: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3284: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3285: raise OKC_API.G_EXCEPTION_ERROR;
3286: END IF;

Line 3283: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

3279: x_msg_data => x_msg_data,
3280: p_ctiv_rec => p_ctiv_rec);
3281:
3282: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3283: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3284: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3285: raise OKC_API.G_EXCEPTION_ERROR;
3286: END IF;
3287:

Line 3284: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN

3280: p_ctiv_rec => p_ctiv_rec);
3281:
3282: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3283: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3284: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3285: raise OKC_API.G_EXCEPTION_ERROR;
3286: END IF;
3287:
3288: -- Call user hook for AFTER

Line 3285: raise OKC_API.G_EXCEPTION_ERROR;

3281:
3282: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3283: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3284: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3285: raise OKC_API.G_EXCEPTION_ERROR;
3286: END IF;
3287:
3288: -- Call user hook for AFTER
3289: g_ctiv_rec := l_ctiv_rec;

Line 3291: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

3287:
3288: -- Call user hook for AFTER
3289: g_ctiv_rec := l_ctiv_rec;
3290: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
3291: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3292: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3293: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3294: raise OKC_API.G_EXCEPTION_ERROR;
3295: END IF;

Line 3292: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

3288: -- Call user hook for AFTER
3289: g_ctiv_rec := l_ctiv_rec;
3290: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
3291: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3292: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3293: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3294: raise OKC_API.G_EXCEPTION_ERROR;
3295: END IF;
3296: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

Line 3293: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN

3289: g_ctiv_rec := l_ctiv_rec;
3290: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
3291: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3292: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3293: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3294: raise OKC_API.G_EXCEPTION_ERROR;
3295: END IF;
3296: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
3297:

Line 3294: raise OKC_API.G_EXCEPTION_ERROR;

3290: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
3291: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3292: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3293: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3294: raise OKC_API.G_EXCEPTION_ERROR;
3295: END IF;
3296: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
3297:
3298:

Line 3296: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

3292: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3293: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3294: raise OKC_API.G_EXCEPTION_ERROR;
3295: END IF;
3296: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
3297:
3298:
3299:
3300:

Line 3302: WHEN OKC_API.G_EXCEPTION_ERROR THEN

3298:
3299:
3300:
3301: EXCEPTION
3302: WHEN OKC_API.G_EXCEPTION_ERROR THEN
3303: x_return_status := OKC_API.HANDLE_EXCEPTIONS
3304: (l_api_name
3305: ,G_PKG_NAME
3306: ,'OKC_API.G_RET_STS_ERROR'

Line 3303: x_return_status := OKC_API.HANDLE_EXCEPTIONS

3299:
3300:
3301: EXCEPTION
3302: WHEN OKC_API.G_EXCEPTION_ERROR THEN
3303: x_return_status := OKC_API.HANDLE_EXCEPTIONS
3304: (l_api_name
3305: ,G_PKG_NAME
3306: ,'OKC_API.G_RET_STS_ERROR'
3307: ,x_msg_count

Line 3306: ,'OKC_API.G_RET_STS_ERROR'

3302: WHEN OKC_API.G_EXCEPTION_ERROR THEN
3303: x_return_status := OKC_API.HANDLE_EXCEPTIONS
3304: (l_api_name
3305: ,G_PKG_NAME
3306: ,'OKC_API.G_RET_STS_ERROR'
3307: ,x_msg_count
3308: ,x_msg_data
3309: ,'_PUB');
3310:

Line 3314: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

3310:
3311:
3312:
3313:
3314: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
3315: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
3316: (l_api_name
3317: ,G_PKG_NAME
3318: ,'OKC_API.G_RET_STS_UNEXP_ERROR'

Line 3315: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

3311:
3312:
3313:
3314: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
3315: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
3316: (l_api_name
3317: ,G_PKG_NAME
3318: ,'OKC_API.G_RET_STS_UNEXP_ERROR'
3319: ,x_msg_count

Line 3318: ,'OKC_API.G_RET_STS_UNEXP_ERROR'

3314: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
3315: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
3316: (l_api_name
3317: ,G_PKG_NAME
3318: ,'OKC_API.G_RET_STS_UNEXP_ERROR'
3319: ,x_msg_count
3320: ,x_msg_data
3321: ,'_PUB');
3322:

Line 3327: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

3323:
3324:
3325:
3326: WHEN OTHERS THEN
3327: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
3328: (l_api_name
3329: ,G_PKG_NAME
3330: ,'OTHERS'
3331: ,x_msg_count

Line 3351: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;

3347: x_msg_count OUT NOCOPY NUMBER,
3348: x_msg_data OUT NOCOPY VARCHAR2,
3349: p_ctiv_tbl IN ctiv_tbl_type) IS
3350: i NUMBER := 0;
3351: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
3352: --
3353: l_proc varchar2(72) := g_package||'delete_cover_time';
3354: --
3355:

Line 3361: x_return_status := OKC_API.G_RET_STS_SUCCESS;

3357:
3358:
3359:
3360:
3361: x_return_status := OKC_API.G_RET_STS_SUCCESS;
3362: IF p_ctiv_tbl.COUNT > 0 THEN
3363: i := p_ctiv_tbl.FIRST;
3364: LOOP
3365: delete_cover_time(

Line 3372: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN

3368: x_return_status => l_return_status,
3369: x_msg_count => x_msg_count,
3370: x_msg_data => x_msg_data,
3371: p_ctiv_rec => p_ctiv_tbl(i));
3372: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
3373: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3374: x_return_status := l_return_status;
3375: raise G_EXCEPTION_HALT_VALIDATION;
3376: ELSE

Line 3373: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

3369: x_msg_count => x_msg_count,
3370: x_msg_data => x_msg_data,
3371: p_ctiv_rec => p_ctiv_tbl(i));
3372: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
3373: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3374: x_return_status := l_return_status;
3375: raise G_EXCEPTION_HALT_VALIDATION;
3376: ELSE
3377: x_return_status := l_return_status;

Line 3397: OKC_API.SET_MESSAGE(

3393:
3394: NULL;
3395: WHEN OTHERS THEN
3396: -- store SQL error message on message stack
3397: OKC_API.SET_MESSAGE(
3398: p_app_name => G_APP_NAME,
3399: p_msg_name => G_UNEXPECTED_ERROR,
3400: p_token1 => G_SQLCODE_TOKEN,
3401: p_token1_value => SQLCODE,

Line 3405: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

3401: p_token1_value => SQLCODE,
3402: p_token2 => G_SQLERRM_TOKEN,
3403: p_token2_value => SQLERRM);
3404: -- notify caller of an error as UNEXPETED error
3405: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
3406:
3407:
3408:
3409:

Line 3451: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;

3447: x_msg_count OUT NOCOPY NUMBER,
3448: x_msg_data OUT NOCOPY VARCHAR2,
3449: p_ctiv_tbl IN ctiv_tbl_type) IS
3450: i NUMBER := 0;
3451: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
3452: --
3453: l_proc varchar2(72) := g_package||'lock_cover_time';
3454: --
3455:

Line 3461: x_return_status := OKC_API.G_RET_STS_SUCCESS;

3457:
3458:
3459:
3460:
3461: x_return_status := OKC_API.G_RET_STS_SUCCESS;
3462: IF p_ctiv_tbl.COUNT > 0 THEN
3463: i := p_ctiv_tbl.FIRST;
3464: LOOP
3465: lock_cover_time(

Line 3472: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN

3468: x_return_status => l_return_status,
3469: x_msg_count => x_msg_count,
3470: x_msg_data => x_msg_data,
3471: p_ctiv_rec => p_ctiv_tbl(i));
3472: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
3473: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3474: x_return_status := l_return_status;
3475: raise G_EXCEPTION_HALT_VALIDATION;
3476: ELSE

Line 3473: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

3469: x_msg_count => x_msg_count,
3470: x_msg_data => x_msg_data,
3471: p_ctiv_rec => p_ctiv_tbl(i));
3472: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
3473: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3474: x_return_status := l_return_status;
3475: raise G_EXCEPTION_HALT_VALIDATION;
3476: ELSE
3477: x_return_status := l_return_status;

Line 3497: OKC_API.SET_MESSAGE(

3493:
3494: NULL;
3495: WHEN OTHERS THEN
3496: -- store SQL error message on message stack
3497: OKC_API.SET_MESSAGE(
3498: p_app_name => G_APP_NAME,
3499: p_msg_name => G_UNEXPECTED_ERROR,
3500: p_token1 => G_SQLCODE_TOKEN,
3501: p_token1_value => SQLCODE,

Line 3505: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

3501: p_token1_value => SQLCODE,
3502: p_token2 => G_SQLERRM_TOKEN,
3503: p_token2_value => SQLERRM);
3504: -- notify caller of an error as UNEXPETED error
3505: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
3506:
3507:
3508:
3509:

Line 3522: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;

3518: x_return_status OUT NOCOPY VARCHAR2,
3519: x_msg_count OUT NOCOPY NUMBER,
3520: x_msg_data OUT NOCOPY VARCHAR2,
3521: p_ctiv_rec IN ctiv_rec_type) IS
3522: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
3523: l_api_name CONSTANT VARCHAR2(30) := 'validate_cover_time';
3524: l_ctiv_rec ctiv_rec_type := p_ctiv_rec;
3525: --
3526: l_proc varchar2(72) := g_package||'validate_cover_time';

Line 3534: l_return_status := OKC_API.START_ACTIVITY(l_api_name,

3530:
3531:
3532:
3533:
3534: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
3535: p_init_msg_list,
3536: '_PUB',
3537: x_return_status);
3538: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

Line 3538: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

3534: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
3535: p_init_msg_list,
3536: '_PUB',
3537: x_return_status);
3538: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3539: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3540: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
3541: raise OKC_API.G_EXCEPTION_ERROR;
3542: END IF;

Line 3539: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

3535: p_init_msg_list,
3536: '_PUB',
3537: x_return_status);
3538: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3539: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3540: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
3541: raise OKC_API.G_EXCEPTION_ERROR;
3542: END IF;
3543: -- Call user hook for BEFORE

Line 3540: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN

3536: '_PUB',
3537: x_return_status);
3538: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3539: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3540: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
3541: raise OKC_API.G_EXCEPTION_ERROR;
3542: END IF;
3543: -- Call user hook for BEFORE
3544: g_ctiv_rec := p_ctiv_rec;

Line 3541: raise OKC_API.G_EXCEPTION_ERROR;

3537: x_return_status);
3538: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3539: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3540: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
3541: raise OKC_API.G_EXCEPTION_ERROR;
3542: END IF;
3543: -- Call user hook for BEFORE
3544: g_ctiv_rec := p_ctiv_rec;
3545: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');

Line 3546: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

3542: END IF;
3543: -- Call user hook for BEFORE
3544: g_ctiv_rec := p_ctiv_rec;
3545: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
3546: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3547: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3548: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3549: raise OKC_API.G_EXCEPTION_ERROR;
3550: END IF;

Line 3547: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

3543: -- Call user hook for BEFORE
3544: g_ctiv_rec := p_ctiv_rec;
3545: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
3546: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3547: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3548: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3549: raise OKC_API.G_EXCEPTION_ERROR;
3550: END IF;
3551:

Line 3548: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN

3544: g_ctiv_rec := p_ctiv_rec;
3545: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
3546: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3547: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3548: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3549: raise OKC_API.G_EXCEPTION_ERROR;
3550: END IF;
3551:
3552: OKC_RULE_PVT.validate_cover_time(

Line 3549: raise OKC_API.G_EXCEPTION_ERROR;

3545: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
3546: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3547: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3548: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3549: raise OKC_API.G_EXCEPTION_ERROR;
3550: END IF;
3551:
3552: OKC_RULE_PVT.validate_cover_time(
3553: p_api_version => p_api_version,

Line 3560: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

3556: x_msg_count => x_msg_count,
3557: x_msg_data => x_msg_data,
3558: p_ctiv_rec => p_ctiv_rec);
3559:
3560: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3561: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3562: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3563: raise OKC_API.G_EXCEPTION_ERROR;
3564: END IF;

Line 3561: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

3557: x_msg_data => x_msg_data,
3558: p_ctiv_rec => p_ctiv_rec);
3559:
3560: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3561: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3562: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3563: raise OKC_API.G_EXCEPTION_ERROR;
3564: END IF;
3565:

Line 3562: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN

3558: p_ctiv_rec => p_ctiv_rec);
3559:
3560: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3561: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3562: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3563: raise OKC_API.G_EXCEPTION_ERROR;
3564: END IF;
3565:
3566: -- Call user hook for AFTER

Line 3563: raise OKC_API.G_EXCEPTION_ERROR;

3559:
3560: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3561: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3562: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3563: raise OKC_API.G_EXCEPTION_ERROR;
3564: END IF;
3565:
3566: -- Call user hook for AFTER
3567: g_ctiv_rec := l_ctiv_rec;

Line 3569: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

3565:
3566: -- Call user hook for AFTER
3567: g_ctiv_rec := l_ctiv_rec;
3568: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
3569: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3570: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3571: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3572: raise OKC_API.G_EXCEPTION_ERROR;
3573: END IF;

Line 3570: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

3566: -- Call user hook for AFTER
3567: g_ctiv_rec := l_ctiv_rec;
3568: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
3569: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3570: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3571: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3572: raise OKC_API.G_EXCEPTION_ERROR;
3573: END IF;
3574: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

Line 3571: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN

3567: g_ctiv_rec := l_ctiv_rec;
3568: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
3569: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3570: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3571: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3572: raise OKC_API.G_EXCEPTION_ERROR;
3573: END IF;
3574: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
3575:

Line 3572: raise OKC_API.G_EXCEPTION_ERROR;

3568: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
3569: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3570: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3571: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3572: raise OKC_API.G_EXCEPTION_ERROR;
3573: END IF;
3574: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
3575:
3576:

Line 3574: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

3570: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3571: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3572: raise OKC_API.G_EXCEPTION_ERROR;
3573: END IF;
3574: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
3575:
3576:
3577:
3578:

Line 3580: WHEN OKC_API.G_EXCEPTION_ERROR THEN

3576:
3577:
3578:
3579: EXCEPTION
3580: WHEN OKC_API.G_EXCEPTION_ERROR THEN
3581: x_return_status := OKC_API.HANDLE_EXCEPTIONS
3582: (l_api_name
3583: ,G_PKG_NAME
3584: ,'OKC_API.G_RET_STS_ERROR'

Line 3581: x_return_status := OKC_API.HANDLE_EXCEPTIONS

3577:
3578:
3579: EXCEPTION
3580: WHEN OKC_API.G_EXCEPTION_ERROR THEN
3581: x_return_status := OKC_API.HANDLE_EXCEPTIONS
3582: (l_api_name
3583: ,G_PKG_NAME
3584: ,'OKC_API.G_RET_STS_ERROR'
3585: ,x_msg_count

Line 3584: ,'OKC_API.G_RET_STS_ERROR'

3580: WHEN OKC_API.G_EXCEPTION_ERROR THEN
3581: x_return_status := OKC_API.HANDLE_EXCEPTIONS
3582: (l_api_name
3583: ,G_PKG_NAME
3584: ,'OKC_API.G_RET_STS_ERROR'
3585: ,x_msg_count
3586: ,x_msg_data
3587: ,'_PUB');
3588:

Line 3592: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

3588:
3589:
3590:
3591:
3592: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
3593: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
3594: (l_api_name
3595: ,G_PKG_NAME
3596: ,'OKC_API.G_RET_STS_UNEXP_ERROR'

Line 3593: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

3589:
3590:
3591:
3592: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
3593: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
3594: (l_api_name
3595: ,G_PKG_NAME
3596: ,'OKC_API.G_RET_STS_UNEXP_ERROR'
3597: ,x_msg_count

Line 3596: ,'OKC_API.G_RET_STS_UNEXP_ERROR'

3592: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
3593: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
3594: (l_api_name
3595: ,G_PKG_NAME
3596: ,'OKC_API.G_RET_STS_UNEXP_ERROR'
3597: ,x_msg_count
3598: ,x_msg_data
3599: ,'_PUB');
3600:

Line 3605: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

3601:
3602:
3603:
3604: WHEN OTHERS THEN
3605: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
3606: (l_api_name
3607: ,G_PKG_NAME
3608: ,'OTHERS'
3609: ,x_msg_count

Line 3629: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;

3625: x_msg_count OUT NOCOPY NUMBER,
3626: x_msg_data OUT NOCOPY VARCHAR2,
3627: p_ctiv_tbl IN ctiv_tbl_type) IS
3628: i NUMBER := 0;
3629: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
3630: --
3631: l_proc varchar2(72) := g_package||'validate_cover_time';
3632: --
3633:

Line 3639: x_return_status := OKC_API.G_RET_STS_SUCCESS;

3635:
3636:
3637:
3638:
3639: x_return_status := OKC_API.G_RET_STS_SUCCESS;
3640: IF p_ctiv_tbl.COUNT > 0 THEN
3641: i := p_ctiv_tbl.FIRST;
3642: LOOP
3643: validate_cover_time(

Line 3650: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN

3646: x_return_status => l_return_status,
3647: x_msg_count => x_msg_count,
3648: x_msg_data => x_msg_data,
3649: p_ctiv_rec => p_ctiv_tbl(i));
3650: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
3651: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3652: x_return_status := l_return_status;
3653: raise G_EXCEPTION_HALT_VALIDATION;
3654: ELSE

Line 3651: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

3647: x_msg_count => x_msg_count,
3648: x_msg_data => x_msg_data,
3649: p_ctiv_rec => p_ctiv_tbl(i));
3650: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
3651: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3652: x_return_status := l_return_status;
3653: raise G_EXCEPTION_HALT_VALIDATION;
3654: ELSE
3655: x_return_status := l_return_status;

Line 3675: OKC_API.SET_MESSAGE(

3671:
3672: NULL;
3673: WHEN OTHERS THEN
3674: -- store SQL error message on message stack
3675: OKC_API.SET_MESSAGE(
3676: p_app_name => G_APP_NAME,
3677: p_msg_name => G_UNEXPECTED_ERROR,
3678: p_token1 => G_SQLCODE_TOKEN,
3679: p_token1_value => SQLCODE,

Line 3683: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

3679: p_token1_value => SQLCODE,
3680: p_token2 => G_SQLERRM_TOKEN,
3681: p_token2_value => SQLERRM);
3682: -- notify caller of an error as UNEXPETED error
3683: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
3684:
3685:
3686:
3687:

Line 3737: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;

3733: x_msg_count OUT NOCOPY NUMBER,
3734: x_msg_data OUT NOCOPY VARCHAR2,
3735: p_rilv_rec IN rilv_rec_type,
3736: x_rilv_rec OUT NOCOPY rilv_rec_type) IS
3737: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
3738: l_api_name CONSTANT VARCHAR2(30) := 'create_react_interval';
3739: l_rilv_rec rilv_rec_type := p_rilv_rec;
3740: --
3741: l_proc varchar2(72) := g_package||'create_react_interval';

Line 3749: l_return_status := OKC_API.START_ACTIVITY(l_api_name,

3745:
3746:
3747:
3748:
3749: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
3750: p_init_msg_list,
3751: '_PUB',
3752: x_return_status);
3753: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

Line 3753: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

3749: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
3750: p_init_msg_list,
3751: '_PUB',
3752: x_return_status);
3753: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3754: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3755: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
3756: raise OKC_API.G_EXCEPTION_ERROR;
3757: END IF;

Line 3754: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

3750: p_init_msg_list,
3751: '_PUB',
3752: x_return_status);
3753: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3754: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3755: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
3756: raise OKC_API.G_EXCEPTION_ERROR;
3757: END IF;
3758: -- Call user hook for BEFORE

Line 3755: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN

3751: '_PUB',
3752: x_return_status);
3753: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3754: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3755: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
3756: raise OKC_API.G_EXCEPTION_ERROR;
3757: END IF;
3758: -- Call user hook for BEFORE
3759: g_rilv_rec := p_rilv_rec;

Line 3756: raise OKC_API.G_EXCEPTION_ERROR;

3752: x_return_status);
3753: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3754: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3755: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
3756: raise OKC_API.G_EXCEPTION_ERROR;
3757: END IF;
3758: -- Call user hook for BEFORE
3759: g_rilv_rec := p_rilv_rec;
3760: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');

Line 3761: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

3757: END IF;
3758: -- Call user hook for BEFORE
3759: g_rilv_rec := p_rilv_rec;
3760: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
3761: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3762: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3763: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3764: raise OKC_API.G_EXCEPTION_ERROR;
3765: END IF;

Line 3762: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

3758: -- Call user hook for BEFORE
3759: g_rilv_rec := p_rilv_rec;
3760: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
3761: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3762: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3763: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3764: raise OKC_API.G_EXCEPTION_ERROR;
3765: END IF;
3766: l_rilv_rec := migrate_rilv(l_rilv_rec, g_rilv_rec);

Line 3763: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN

3759: g_rilv_rec := p_rilv_rec;
3760: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
3761: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3762: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3763: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3764: raise OKC_API.G_EXCEPTION_ERROR;
3765: END IF;
3766: l_rilv_rec := migrate_rilv(l_rilv_rec, g_rilv_rec);
3767:

Line 3764: raise OKC_API.G_EXCEPTION_ERROR;

3760: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
3761: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3762: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3763: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3764: raise OKC_API.G_EXCEPTION_ERROR;
3765: END IF;
3766: l_rilv_rec := migrate_rilv(l_rilv_rec, g_rilv_rec);
3767:
3768: OKC_RULE_PVT.create_react_interval(

Line 3777: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

3773: x_msg_data => x_msg_data,
3774: p_rilv_rec => l_rilv_rec,
3775: x_rilv_rec => x_rilv_rec);
3776:
3777: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3778: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3779: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3780: raise OKC_API.G_EXCEPTION_ERROR;
3781: END IF;

Line 3778: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

3774: p_rilv_rec => l_rilv_rec,
3775: x_rilv_rec => x_rilv_rec);
3776:
3777: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3778: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3779: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3780: raise OKC_API.G_EXCEPTION_ERROR;
3781: END IF;
3782:

Line 3779: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN

3775: x_rilv_rec => x_rilv_rec);
3776:
3777: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3778: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3779: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3780: raise OKC_API.G_EXCEPTION_ERROR;
3781: END IF;
3782:
3783: -- Call user hook for AFTER

Line 3780: raise OKC_API.G_EXCEPTION_ERROR;

3776:
3777: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3778: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3779: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3780: raise OKC_API.G_EXCEPTION_ERROR;
3781: END IF;
3782:
3783: -- Call user hook for AFTER
3784: g_rilv_rec := x_rilv_rec;

Line 3786: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

3782:
3783: -- Call user hook for AFTER
3784: g_rilv_rec := x_rilv_rec;
3785: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
3786: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3787: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3788: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3789: raise OKC_API.G_EXCEPTION_ERROR;
3790: END IF;

Line 3787: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

3783: -- Call user hook for AFTER
3784: g_rilv_rec := x_rilv_rec;
3785: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
3786: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3787: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3788: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3789: raise OKC_API.G_EXCEPTION_ERROR;
3790: END IF;
3791: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

Line 3788: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN

3784: g_rilv_rec := x_rilv_rec;
3785: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
3786: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3787: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3788: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3789: raise OKC_API.G_EXCEPTION_ERROR;
3790: END IF;
3791: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
3792:

Line 3789: raise OKC_API.G_EXCEPTION_ERROR;

3785: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
3786: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3787: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3788: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3789: raise OKC_API.G_EXCEPTION_ERROR;
3790: END IF;
3791: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
3792:
3793:

Line 3791: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

3787: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3788: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3789: raise OKC_API.G_EXCEPTION_ERROR;
3790: END IF;
3791: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
3792:
3793:
3794:
3795:

Line 3797: WHEN OKC_API.G_EXCEPTION_ERROR THEN

3793:
3794:
3795:
3796: EXCEPTION
3797: WHEN OKC_API.G_EXCEPTION_ERROR THEN
3798: x_return_status := OKC_API.HANDLE_EXCEPTIONS
3799: (l_api_name
3800: ,G_PKG_NAME
3801: ,'OKC_API.G_RET_STS_ERROR'

Line 3798: x_return_status := OKC_API.HANDLE_EXCEPTIONS

3794:
3795:
3796: EXCEPTION
3797: WHEN OKC_API.G_EXCEPTION_ERROR THEN
3798: x_return_status := OKC_API.HANDLE_EXCEPTIONS
3799: (l_api_name
3800: ,G_PKG_NAME
3801: ,'OKC_API.G_RET_STS_ERROR'
3802: ,x_msg_count

Line 3801: ,'OKC_API.G_RET_STS_ERROR'

3797: WHEN OKC_API.G_EXCEPTION_ERROR THEN
3798: x_return_status := OKC_API.HANDLE_EXCEPTIONS
3799: (l_api_name
3800: ,G_PKG_NAME
3801: ,'OKC_API.G_RET_STS_ERROR'
3802: ,x_msg_count
3803: ,x_msg_data
3804: ,'_PUB');
3805:

Line 3809: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

3805:
3806:
3807:
3808:
3809: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
3810: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
3811: (l_api_name
3812: ,G_PKG_NAME
3813: ,'OKC_API.G_RET_STS_UNEXP_ERROR'

Line 3810: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

3806:
3807:
3808:
3809: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
3810: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
3811: (l_api_name
3812: ,G_PKG_NAME
3813: ,'OKC_API.G_RET_STS_UNEXP_ERROR'
3814: ,x_msg_count

Line 3813: ,'OKC_API.G_RET_STS_UNEXP_ERROR'

3809: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
3810: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
3811: (l_api_name
3812: ,G_PKG_NAME
3813: ,'OKC_API.G_RET_STS_UNEXP_ERROR'
3814: ,x_msg_count
3815: ,x_msg_data
3816: ,'_PUB');
3817:

Line 3822: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

3818:
3819:
3820:
3821: WHEN OTHERS THEN
3822: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
3823: (l_api_name
3824: ,G_PKG_NAME
3825: ,'OTHERS'
3826: ,x_msg_count

Line 3847: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;

3843: x_msg_data OUT NOCOPY VARCHAR2,
3844: p_rilv_tbl IN rilv_tbl_type,
3845: x_rilv_tbl OUT NOCOPY rilv_tbl_type) IS
3846: i NUMBER := 0;
3847: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
3848: --
3849: l_proc varchar2(72) := g_package||'create_react_interval';
3850: --
3851:

Line 3857: x_return_status := OKC_API.G_RET_STS_SUCCESS;

3853:
3854:
3855:
3856:
3857: x_return_status := OKC_API.G_RET_STS_SUCCESS;
3858: IF p_rilv_tbl.COUNT > 0 THEN
3859: i := p_rilv_tbl.FIRST;
3860: LOOP
3861: create_react_interval(

Line 3869: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN

3865: x_msg_count => x_msg_count,
3866: x_msg_data => x_msg_data,
3867: p_rilv_rec => p_rilv_tbl(i),
3868: x_rilv_rec => x_rilv_tbl(i));
3869: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
3870: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3871: x_return_status := l_return_status;
3872: raise G_EXCEPTION_HALT_VALIDATION;
3873: ELSE

Line 3870: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

3866: x_msg_data => x_msg_data,
3867: p_rilv_rec => p_rilv_tbl(i),
3868: x_rilv_rec => x_rilv_tbl(i));
3869: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
3870: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3871: x_return_status := l_return_status;
3872: raise G_EXCEPTION_HALT_VALIDATION;
3873: ELSE
3874: x_return_status := l_return_status;

Line 3894: OKC_API.SET_MESSAGE(

3890:
3891: NULL;
3892: WHEN OTHERS THEN
3893: -- store SQL error message on message stack
3894: OKC_API.SET_MESSAGE(
3895: p_app_name => G_APP_NAME,
3896: p_msg_name => G_UNEXPECTED_ERROR,
3897: p_token1 => G_SQLCODE_TOKEN,
3898: p_token1_value => SQLCODE,

Line 3902: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

3898: p_token1_value => SQLCODE,
3899: p_token2 => G_SQLERRM_TOKEN,
3900: p_token2_value => SQLERRM);
3901: -- notify caller of an error as UNEXPETED error
3902: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
3903:
3904:
3905:
3906:

Line 3920: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;

3916: x_msg_count OUT NOCOPY NUMBER,
3917: x_msg_data OUT NOCOPY VARCHAR2,
3918: p_rilv_rec IN rilv_rec_type,
3919: x_rilv_rec OUT NOCOPY rilv_rec_type) IS
3920: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
3921: l_api_name CONSTANT VARCHAR2(30) := 'update_react_interval';
3922: l_rilv_rec rilv_rec_type := p_rilv_rec;
3923: --
3924: l_proc varchar2(72) := g_package||'update_react_interval';

Line 3932: l_return_status := OKC_API.START_ACTIVITY(l_api_name,

3928:
3929:
3930:
3931:
3932: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
3933: p_init_msg_list,
3934: '_PUB',
3935: x_return_status);
3936: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

Line 3936: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

3932: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
3933: p_init_msg_list,
3934: '_PUB',
3935: x_return_status);
3936: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3937: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3938: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
3939: raise OKC_API.G_EXCEPTION_ERROR;
3940: END IF;

Line 3937: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

3933: p_init_msg_list,
3934: '_PUB',
3935: x_return_status);
3936: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3937: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3938: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
3939: raise OKC_API.G_EXCEPTION_ERROR;
3940: END IF;
3941: -- Call user hook for BEFORE

Line 3938: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN

3934: '_PUB',
3935: x_return_status);
3936: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3937: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3938: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
3939: raise OKC_API.G_EXCEPTION_ERROR;
3940: END IF;
3941: -- Call user hook for BEFORE
3942: g_rilv_rec := p_rilv_rec;

Line 3939: raise OKC_API.G_EXCEPTION_ERROR;

3935: x_return_status);
3936: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3937: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3938: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
3939: raise OKC_API.G_EXCEPTION_ERROR;
3940: END IF;
3941: -- Call user hook for BEFORE
3942: g_rilv_rec := p_rilv_rec;
3943: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');

Line 3944: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

3940: END IF;
3941: -- Call user hook for BEFORE
3942: g_rilv_rec := p_rilv_rec;
3943: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
3944: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3945: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3946: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3947: raise OKC_API.G_EXCEPTION_ERROR;
3948: END IF;

Line 3945: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

3941: -- Call user hook for BEFORE
3942: g_rilv_rec := p_rilv_rec;
3943: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
3944: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3945: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3946: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3947: raise OKC_API.G_EXCEPTION_ERROR;
3948: END IF;
3949: l_rilv_rec := migrate_rilv(l_rilv_rec, g_rilv_rec);

Line 3946: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN

3942: g_rilv_rec := p_rilv_rec;
3943: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
3944: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3945: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3946: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3947: raise OKC_API.G_EXCEPTION_ERROR;
3948: END IF;
3949: l_rilv_rec := migrate_rilv(l_rilv_rec, g_rilv_rec);
3950:

Line 3947: raise OKC_API.G_EXCEPTION_ERROR;

3943: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
3944: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3945: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3946: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3947: raise OKC_API.G_EXCEPTION_ERROR;
3948: END IF;
3949: l_rilv_rec := migrate_rilv(l_rilv_rec, g_rilv_rec);
3950:
3951: OKC_RULE_PVT.update_react_interval(

Line 3960: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

3956: x_msg_data => x_msg_data,
3957: p_rilv_rec => l_rilv_rec,
3958: x_rilv_rec => x_rilv_rec);
3959:
3960: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3961: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3962: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3963: raise OKC_API.G_EXCEPTION_ERROR;
3964: END IF;

Line 3961: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

3957: p_rilv_rec => l_rilv_rec,
3958: x_rilv_rec => x_rilv_rec);
3959:
3960: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3961: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3962: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3963: raise OKC_API.G_EXCEPTION_ERROR;
3964: END IF;
3965:

Line 3962: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN

3958: x_rilv_rec => x_rilv_rec);
3959:
3960: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3961: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3962: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3963: raise OKC_API.G_EXCEPTION_ERROR;
3964: END IF;
3965:
3966: -- Call user hook for AFTER

Line 3963: raise OKC_API.G_EXCEPTION_ERROR;

3959:
3960: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3961: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3962: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3963: raise OKC_API.G_EXCEPTION_ERROR;
3964: END IF;
3965:
3966: -- Call user hook for AFTER
3967: g_rilv_rec := x_rilv_rec;

Line 3969: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

3965:
3966: -- Call user hook for AFTER
3967: g_rilv_rec := x_rilv_rec;
3968: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
3969: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3970: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3971: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3972: raise OKC_API.G_EXCEPTION_ERROR;
3973: END IF;

Line 3970: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

3966: -- Call user hook for AFTER
3967: g_rilv_rec := x_rilv_rec;
3968: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
3969: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3970: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3971: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3972: raise OKC_API.G_EXCEPTION_ERROR;
3973: END IF;
3974: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

Line 3971: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN

3967: g_rilv_rec := x_rilv_rec;
3968: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
3969: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3970: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3971: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3972: raise OKC_API.G_EXCEPTION_ERROR;
3973: END IF;
3974: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
3975:

Line 3972: raise OKC_API.G_EXCEPTION_ERROR;

3968: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
3969: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3970: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3971: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3972: raise OKC_API.G_EXCEPTION_ERROR;
3973: END IF;
3974: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
3975:
3976:

Line 3974: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

3970: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3971: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3972: raise OKC_API.G_EXCEPTION_ERROR;
3973: END IF;
3974: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
3975:
3976:
3977:
3978:

Line 3980: WHEN OKC_API.G_EXCEPTION_ERROR THEN

3976:
3977:
3978:
3979: EXCEPTION
3980: WHEN OKC_API.G_EXCEPTION_ERROR THEN
3981: x_return_status := OKC_API.HANDLE_EXCEPTIONS
3982: (l_api_name
3983: ,G_PKG_NAME
3984: ,'OKC_API.G_RET_STS_ERROR'

Line 3981: x_return_status := OKC_API.HANDLE_EXCEPTIONS

3977:
3978:
3979: EXCEPTION
3980: WHEN OKC_API.G_EXCEPTION_ERROR THEN
3981: x_return_status := OKC_API.HANDLE_EXCEPTIONS
3982: (l_api_name
3983: ,G_PKG_NAME
3984: ,'OKC_API.G_RET_STS_ERROR'
3985: ,x_msg_count

Line 3984: ,'OKC_API.G_RET_STS_ERROR'

3980: WHEN OKC_API.G_EXCEPTION_ERROR THEN
3981: x_return_status := OKC_API.HANDLE_EXCEPTIONS
3982: (l_api_name
3983: ,G_PKG_NAME
3984: ,'OKC_API.G_RET_STS_ERROR'
3985: ,x_msg_count
3986: ,x_msg_data
3987: ,'_PUB');
3988:

Line 3992: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

3988:
3989:
3990:
3991:
3992: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
3993: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
3994: (l_api_name
3995: ,G_PKG_NAME
3996: ,'OKC_API.G_RET_STS_UNEXP_ERROR'

Line 3993: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

3989:
3990:
3991:
3992: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
3993: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
3994: (l_api_name
3995: ,G_PKG_NAME
3996: ,'OKC_API.G_RET_STS_UNEXP_ERROR'
3997: ,x_msg_count

Line 3996: ,'OKC_API.G_RET_STS_UNEXP_ERROR'

3992: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
3993: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
3994: (l_api_name
3995: ,G_PKG_NAME
3996: ,'OKC_API.G_RET_STS_UNEXP_ERROR'
3997: ,x_msg_count
3998: ,x_msg_data
3999: ,'_PUB');
4000:

Line 4005: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

4001:
4002:
4003:
4004: WHEN OTHERS THEN
4005: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
4006: (l_api_name
4007: ,G_PKG_NAME
4008: ,'OTHERS'
4009: ,x_msg_count

Line 4030: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;

4026: x_msg_data OUT NOCOPY VARCHAR2,
4027: p_rilv_tbl IN rilv_tbl_type,
4028: x_rilv_tbl OUT NOCOPY rilv_tbl_type) IS
4029: i NUMBER := 0;
4030: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
4031: --
4032: l_proc varchar2(72) := g_package||'update_react_interval';
4033: --
4034:

Line 4040: x_return_status := OKC_API.G_RET_STS_SUCCESS;

4036:
4037:
4038:
4039:
4040: x_return_status := OKC_API.G_RET_STS_SUCCESS;
4041: IF p_rilv_tbl.COUNT > 0 THEN
4042: i := p_rilv_tbl.FIRST;
4043: LOOP
4044: update_react_interval(

Line 4052: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN

4048: x_msg_count => x_msg_count,
4049: x_msg_data => x_msg_data,
4050: p_rilv_rec => p_rilv_tbl(i),
4051: x_rilv_rec => x_rilv_tbl(i));
4052: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
4053: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
4054: x_return_status := l_return_status;
4055: raise G_EXCEPTION_HALT_VALIDATION;
4056: ELSE

Line 4053: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

4049: x_msg_data => x_msg_data,
4050: p_rilv_rec => p_rilv_tbl(i),
4051: x_rilv_rec => x_rilv_tbl(i));
4052: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
4053: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
4054: x_return_status := l_return_status;
4055: raise G_EXCEPTION_HALT_VALIDATION;
4056: ELSE
4057: x_return_status := l_return_status;

Line 4077: OKC_API.SET_MESSAGE(

4073:
4074: NULL;
4075: WHEN OTHERS THEN
4076: -- store SQL error message on message stack
4077: OKC_API.SET_MESSAGE(
4078: p_app_name => G_APP_NAME,
4079: p_msg_name => G_UNEXPECTED_ERROR,
4080: p_token1 => G_SQLCODE_TOKEN,
4081: p_token1_value => SQLCODE,

Line 4085: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

4081: p_token1_value => SQLCODE,
4082: p_token2 => G_SQLERRM_TOKEN,
4083: p_token2_value => SQLERRM);
4084: -- notify caller of an error as UNEXPETED error
4085: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
4086:
4087:
4088:
4089:

Line 4102: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;

4098: x_return_status OUT NOCOPY VARCHAR2,
4099: x_msg_count OUT NOCOPY NUMBER,
4100: x_msg_data OUT NOCOPY VARCHAR2,
4101: p_rilv_rec IN rilv_rec_type) IS
4102: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
4103: l_api_name CONSTANT VARCHAR2(30) := 'delete_react_interval';
4104: l_rilv_rec rilv_rec_type := p_rilv_rec;
4105: --
4106: l_proc varchar2(72) := g_package||'delete_react_interval';

Line 4114: l_return_status := OKC_API.START_ACTIVITY(l_api_name,

4110:
4111:
4112:
4113:
4114: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
4115: p_init_msg_list,
4116: '_PUB',
4117: x_return_status);
4118: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

Line 4118: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

4114: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
4115: p_init_msg_list,
4116: '_PUB',
4117: x_return_status);
4118: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
4119: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
4120: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
4121: raise OKC_API.G_EXCEPTION_ERROR;
4122: END IF;

Line 4119: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

4115: p_init_msg_list,
4116: '_PUB',
4117: x_return_status);
4118: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
4119: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
4120: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
4121: raise OKC_API.G_EXCEPTION_ERROR;
4122: END IF;
4123: -- Call user hook for BEFORE

Line 4120: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN

4116: '_PUB',
4117: x_return_status);
4118: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
4119: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
4120: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
4121: raise OKC_API.G_EXCEPTION_ERROR;
4122: END IF;
4123: -- Call user hook for BEFORE
4124: g_rilv_rec := p_rilv_rec;

Line 4121: raise OKC_API.G_EXCEPTION_ERROR;

4117: x_return_status);
4118: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
4119: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
4120: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
4121: raise OKC_API.G_EXCEPTION_ERROR;
4122: END IF;
4123: -- Call user hook for BEFORE
4124: g_rilv_rec := p_rilv_rec;
4125: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');

Line 4126: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

4122: END IF;
4123: -- Call user hook for BEFORE
4124: g_rilv_rec := p_rilv_rec;
4125: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
4126: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
4127: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
4128: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
4129: raise OKC_API.G_EXCEPTION_ERROR;
4130: END IF;

Line 4127: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

4123: -- Call user hook for BEFORE
4124: g_rilv_rec := p_rilv_rec;
4125: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
4126: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
4127: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
4128: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
4129: raise OKC_API.G_EXCEPTION_ERROR;
4130: END IF;
4131:

Line 4128: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN

4124: g_rilv_rec := p_rilv_rec;
4125: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
4126: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
4127: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
4128: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
4129: raise OKC_API.G_EXCEPTION_ERROR;
4130: END IF;
4131:
4132: OKC_RULE_PVT.delete_react_interval(

Line 4129: raise OKC_API.G_EXCEPTION_ERROR;

4125: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
4126: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
4127: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
4128: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
4129: raise OKC_API.G_EXCEPTION_ERROR;
4130: END IF;
4131:
4132: OKC_RULE_PVT.delete_react_interval(
4133: p_api_version => p_api_version,

Line 4140: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

4136: x_msg_count => x_msg_count,
4137: x_msg_data => x_msg_data,
4138: p_rilv_rec => p_rilv_rec);
4139:
4140: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
4141: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
4142: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
4143: raise OKC_API.G_EXCEPTION_ERROR;
4144: END IF;

Line 4141: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

4137: x_msg_data => x_msg_data,
4138: p_rilv_rec => p_rilv_rec);
4139:
4140: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
4141: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
4142: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
4143: raise OKC_API.G_EXCEPTION_ERROR;
4144: END IF;
4145:

Line 4142: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN

4138: p_rilv_rec => p_rilv_rec);
4139:
4140: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
4141: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
4142: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
4143: raise OKC_API.G_EXCEPTION_ERROR;
4144: END IF;
4145:
4146: -- Call user hook for AFTER

Line 4143: raise OKC_API.G_EXCEPTION_ERROR;

4139:
4140: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
4141: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
4142: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
4143: raise OKC_API.G_EXCEPTION_ERROR;
4144: END IF;
4145:
4146: -- Call user hook for AFTER
4147: g_rilv_rec := l_rilv_rec;

Line 4149: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

4145:
4146: -- Call user hook for AFTER
4147: g_rilv_rec := l_rilv_rec;
4148: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
4149: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
4150: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
4151: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
4152: raise OKC_API.G_EXCEPTION_ERROR;
4153: END IF;

Line 4150: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

4146: -- Call user hook for AFTER
4147: g_rilv_rec := l_rilv_rec;
4148: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
4149: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
4150: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
4151: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
4152: raise OKC_API.G_EXCEPTION_ERROR;
4153: END IF;
4154: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

Line 4151: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN

4147: g_rilv_rec := l_rilv_rec;
4148: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
4149: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
4150: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
4151: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
4152: raise OKC_API.G_EXCEPTION_ERROR;
4153: END IF;
4154: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
4155:

Line 4152: raise OKC_API.G_EXCEPTION_ERROR;

4148: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
4149: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
4150: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
4151: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
4152: raise OKC_API.G_EXCEPTION_ERROR;
4153: END IF;
4154: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
4155:
4156:

Line 4154: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

4150: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
4151: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
4152: raise OKC_API.G_EXCEPTION_ERROR;
4153: END IF;
4154: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
4155:
4156:
4157:
4158:

Line 4160: WHEN OKC_API.G_EXCEPTION_ERROR THEN

4156:
4157:
4158:
4159: EXCEPTION
4160: WHEN OKC_API.G_EXCEPTION_ERROR THEN
4161: x_return_status := OKC_API.HANDLE_EXCEPTIONS
4162: (l_api_name
4163: ,G_PKG_NAME
4164: ,'OKC_API.G_RET_STS_ERROR'

Line 4161: x_return_status := OKC_API.HANDLE_EXCEPTIONS

4157:
4158:
4159: EXCEPTION
4160: WHEN OKC_API.G_EXCEPTION_ERROR THEN
4161: x_return_status := OKC_API.HANDLE_EXCEPTIONS
4162: (l_api_name
4163: ,G_PKG_NAME
4164: ,'OKC_API.G_RET_STS_ERROR'
4165: ,x_msg_count

Line 4164: ,'OKC_API.G_RET_STS_ERROR'

4160: WHEN OKC_API.G_EXCEPTION_ERROR THEN
4161: x_return_status := OKC_API.HANDLE_EXCEPTIONS
4162: (l_api_name
4163: ,G_PKG_NAME
4164: ,'OKC_API.G_RET_STS_ERROR'
4165: ,x_msg_count
4166: ,x_msg_data
4167: ,'_PUB');
4168:

Line 4172: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

4168:
4169:
4170:
4171:
4172: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
4173: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
4174: (l_api_name
4175: ,G_PKG_NAME
4176: ,'OKC_API.G_RET_STS_UNEXP_ERROR'

Line 4173: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

4169:
4170:
4171:
4172: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
4173: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
4174: (l_api_name
4175: ,G_PKG_NAME
4176: ,'OKC_API.G_RET_STS_UNEXP_ERROR'
4177: ,x_msg_count

Line 4176: ,'OKC_API.G_RET_STS_UNEXP_ERROR'

4172: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
4173: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
4174: (l_api_name
4175: ,G_PKG_NAME
4176: ,'OKC_API.G_RET_STS_UNEXP_ERROR'
4177: ,x_msg_count
4178: ,x_msg_data
4179: ,'_PUB');
4180:

Line 4185: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

4181:
4182:
4183:
4184: WHEN OTHERS THEN
4185: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
4186: (l_api_name
4187: ,G_PKG_NAME
4188: ,'OTHERS'
4189: ,x_msg_count

Line 4209: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;

4205: x_msg_count OUT NOCOPY NUMBER,
4206: x_msg_data OUT NOCOPY VARCHAR2,
4207: p_rilv_tbl IN rilv_tbl_type) IS
4208: i NUMBER := 0;
4209: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
4210: --
4211: l_proc varchar2(72) := g_package||'delete_react_interval';
4212: --
4213:

Line 4219: x_return_status := OKC_API.G_RET_STS_SUCCESS;

4215:
4216:
4217:
4218:
4219: x_return_status := OKC_API.G_RET_STS_SUCCESS;
4220: IF p_rilv_tbl.COUNT > 0 THEN
4221: i := p_rilv_tbl.FIRST;
4222: LOOP
4223: delete_react_interval(

Line 4230: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN

4226: x_return_status => l_return_status,
4227: x_msg_count => x_msg_count,
4228: x_msg_data => x_msg_data,
4229: p_rilv_rec => p_rilv_tbl(i));
4230: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
4231: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
4232: x_return_status := l_return_status;
4233: raise G_EXCEPTION_HALT_VALIDATION;
4234: ELSE

Line 4231: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

4227: x_msg_count => x_msg_count,
4228: x_msg_data => x_msg_data,
4229: p_rilv_rec => p_rilv_tbl(i));
4230: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
4231: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
4232: x_return_status := l_return_status;
4233: raise G_EXCEPTION_HALT_VALIDATION;
4234: ELSE
4235: x_return_status := l_return_status;

Line 4255: OKC_API.SET_MESSAGE(

4251:
4252: NULL;
4253: WHEN OTHERS THEN
4254: -- store SQL error message on message stack
4255: OKC_API.SET_MESSAGE(
4256: p_app_name => G_APP_NAME,
4257: p_msg_name => G_UNEXPECTED_ERROR,
4258: p_token1 => G_SQLCODE_TOKEN,
4259: p_token1_value => SQLCODE,

Line 4263: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

4259: p_token1_value => SQLCODE,
4260: p_token2 => G_SQLERRM_TOKEN,
4261: p_token2_value => SQLERRM);
4262: -- notify caller of an error as UNEXPETED error
4263: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
4264:
4265:
4266:
4267:

Line 4309: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;

4305: x_msg_count OUT NOCOPY NUMBER,
4306: x_msg_data OUT NOCOPY VARCHAR2,
4307: p_rilv_tbl IN rilv_tbl_type) IS
4308: i NUMBER := 0;
4309: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
4310: --
4311: l_proc varchar2(72) := g_package||'lock_react_interval';
4312: --
4313:

Line 4319: x_return_status := OKC_API.G_RET_STS_SUCCESS;

4315:
4316:
4317:
4318:
4319: x_return_status := OKC_API.G_RET_STS_SUCCESS;
4320: IF p_rilv_tbl.COUNT > 0 THEN
4321: i := p_rilv_tbl.FIRST;
4322: LOOP
4323: lock_react_interval(

Line 4330: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN

4326: x_return_status => l_return_status,
4327: x_msg_count => x_msg_count,
4328: x_msg_data => x_msg_data,
4329: p_rilv_rec => p_rilv_tbl(i));
4330: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
4331: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
4332: x_return_status := l_return_status;
4333: raise G_EXCEPTION_HALT_VALIDATION;
4334: ELSE

Line 4331: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

4327: x_msg_count => x_msg_count,
4328: x_msg_data => x_msg_data,
4329: p_rilv_rec => p_rilv_tbl(i));
4330: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
4331: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
4332: x_return_status := l_return_status;
4333: raise G_EXCEPTION_HALT_VALIDATION;
4334: ELSE
4335: x_return_status := l_return_status;

Line 4355: OKC_API.SET_MESSAGE(

4351:
4352: NULL;
4353: WHEN OTHERS THEN
4354: -- store SQL error message on message stack
4355: OKC_API.SET_MESSAGE(
4356: p_app_name => G_APP_NAME,
4357: p_msg_name => G_UNEXPECTED_ERROR,
4358: p_token1 => G_SQLCODE_TOKEN,
4359: p_token1_value => SQLCODE,

Line 4363: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

4359: p_token1_value => SQLCODE,
4360: p_token2 => G_SQLERRM_TOKEN,
4361: p_token2_value => SQLERRM);
4362: -- notify caller of an error as UNEXPETED error
4363: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
4364:
4365:
4366:
4367:

Line 4380: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;

4376: x_return_status OUT NOCOPY VARCHAR2,
4377: x_msg_count OUT NOCOPY NUMBER,
4378: x_msg_data OUT NOCOPY VARCHAR2,
4379: p_rilv_rec IN rilv_rec_type) IS
4380: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
4381: l_api_name CONSTANT VARCHAR2(30) := 'validate_react_interval';
4382: l_rilv_rec rilv_rec_type := p_rilv_rec;
4383: --
4384: l_proc varchar2(72) := g_package||'validate_react_interval';

Line 4392: l_return_status := OKC_API.START_ACTIVITY(l_api_name,

4388:
4389:
4390:
4391:
4392: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
4393: p_init_msg_list,
4394: '_PUB',
4395: x_return_status);
4396: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

Line 4396: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

4392: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
4393: p_init_msg_list,
4394: '_PUB',
4395: x_return_status);
4396: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
4397: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
4398: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
4399: raise OKC_API.G_EXCEPTION_ERROR;
4400: END IF;

Line 4397: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

4393: p_init_msg_list,
4394: '_PUB',
4395: x_return_status);
4396: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
4397: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
4398: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
4399: raise OKC_API.G_EXCEPTION_ERROR;
4400: END IF;
4401: -- Call user hook for BEFORE

Line 4398: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN

4394: '_PUB',
4395: x_return_status);
4396: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
4397: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
4398: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
4399: raise OKC_API.G_EXCEPTION_ERROR;
4400: END IF;
4401: -- Call user hook for BEFORE
4402: g_rilv_rec := p_rilv_rec;

Line 4399: raise OKC_API.G_EXCEPTION_ERROR;

4395: x_return_status);
4396: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
4397: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
4398: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
4399: raise OKC_API.G_EXCEPTION_ERROR;
4400: END IF;
4401: -- Call user hook for BEFORE
4402: g_rilv_rec := p_rilv_rec;
4403: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');

Line 4404: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

4400: END IF;
4401: -- Call user hook for BEFORE
4402: g_rilv_rec := p_rilv_rec;
4403: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
4404: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
4405: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
4406: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
4407: raise OKC_API.G_EXCEPTION_ERROR;
4408: END IF;

Line 4405: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

4401: -- Call user hook for BEFORE
4402: g_rilv_rec := p_rilv_rec;
4403: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
4404: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
4405: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
4406: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
4407: raise OKC_API.G_EXCEPTION_ERROR;
4408: END IF;
4409:

Line 4406: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN

4402: g_rilv_rec := p_rilv_rec;
4403: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
4404: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
4405: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
4406: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
4407: raise OKC_API.G_EXCEPTION_ERROR;
4408: END IF;
4409:
4410: OKC_RULE_PVT.validate_react_interval(

Line 4407: raise OKC_API.G_EXCEPTION_ERROR;

4403: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
4404: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
4405: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
4406: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
4407: raise OKC_API.G_EXCEPTION_ERROR;
4408: END IF;
4409:
4410: OKC_RULE_PVT.validate_react_interval(
4411: p_api_version => p_api_version,

Line 4418: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

4414: x_msg_count => x_msg_count,
4415: x_msg_data => x_msg_data,
4416: p_rilv_rec => p_rilv_rec);
4417:
4418: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
4419: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
4420: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
4421: raise OKC_API.G_EXCEPTION_ERROR;
4422: END IF;

Line 4419: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

4415: x_msg_data => x_msg_data,
4416: p_rilv_rec => p_rilv_rec);
4417:
4418: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
4419: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
4420: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
4421: raise OKC_API.G_EXCEPTION_ERROR;
4422: END IF;
4423:

Line 4420: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN

4416: p_rilv_rec => p_rilv_rec);
4417:
4418: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
4419: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
4420: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
4421: raise OKC_API.G_EXCEPTION_ERROR;
4422: END IF;
4423:
4424: -- Call user hook for AFTER

Line 4421: raise OKC_API.G_EXCEPTION_ERROR;

4417:
4418: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
4419: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
4420: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
4421: raise OKC_API.G_EXCEPTION_ERROR;
4422: END IF;
4423:
4424: -- Call user hook for AFTER
4425: g_rilv_rec := l_rilv_rec;

Line 4427: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

4423:
4424: -- Call user hook for AFTER
4425: g_rilv_rec := l_rilv_rec;
4426: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
4427: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
4428: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
4429: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
4430: raise OKC_API.G_EXCEPTION_ERROR;
4431: END IF;

Line 4428: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

4424: -- Call user hook for AFTER
4425: g_rilv_rec := l_rilv_rec;
4426: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
4427: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
4428: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
4429: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
4430: raise OKC_API.G_EXCEPTION_ERROR;
4431: END IF;
4432: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

Line 4429: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN

4425: g_rilv_rec := l_rilv_rec;
4426: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
4427: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
4428: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
4429: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
4430: raise OKC_API.G_EXCEPTION_ERROR;
4431: END IF;
4432: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
4433:

Line 4430: raise OKC_API.G_EXCEPTION_ERROR;

4426: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
4427: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
4428: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
4429: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
4430: raise OKC_API.G_EXCEPTION_ERROR;
4431: END IF;
4432: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
4433:
4434:

Line 4432: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

4428: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
4429: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
4430: raise OKC_API.G_EXCEPTION_ERROR;
4431: END IF;
4432: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
4433:
4434:
4435:
4436:

Line 4438: WHEN OKC_API.G_EXCEPTION_ERROR THEN

4434:
4435:
4436:
4437: EXCEPTION
4438: WHEN OKC_API.G_EXCEPTION_ERROR THEN
4439: x_return_status := OKC_API.HANDLE_EXCEPTIONS
4440: (l_api_name
4441: ,G_PKG_NAME
4442: ,'OKC_API.G_RET_STS_ERROR'

Line 4439: x_return_status := OKC_API.HANDLE_EXCEPTIONS

4435:
4436:
4437: EXCEPTION
4438: WHEN OKC_API.G_EXCEPTION_ERROR THEN
4439: x_return_status := OKC_API.HANDLE_EXCEPTIONS
4440: (l_api_name
4441: ,G_PKG_NAME
4442: ,'OKC_API.G_RET_STS_ERROR'
4443: ,x_msg_count

Line 4442: ,'OKC_API.G_RET_STS_ERROR'

4438: WHEN OKC_API.G_EXCEPTION_ERROR THEN
4439: x_return_status := OKC_API.HANDLE_EXCEPTIONS
4440: (l_api_name
4441: ,G_PKG_NAME
4442: ,'OKC_API.G_RET_STS_ERROR'
4443: ,x_msg_count
4444: ,x_msg_data
4445: ,'_PUB');
4446:

Line 4450: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

4446:
4447:
4448:
4449:
4450: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
4451: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
4452: (l_api_name
4453: ,G_PKG_NAME
4454: ,'OKC_API.G_RET_STS_UNEXP_ERROR'

Line 4451: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

4447:
4448:
4449:
4450: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
4451: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
4452: (l_api_name
4453: ,G_PKG_NAME
4454: ,'OKC_API.G_RET_STS_UNEXP_ERROR'
4455: ,x_msg_count

Line 4454: ,'OKC_API.G_RET_STS_UNEXP_ERROR'

4450: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
4451: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
4452: (l_api_name
4453: ,G_PKG_NAME
4454: ,'OKC_API.G_RET_STS_UNEXP_ERROR'
4455: ,x_msg_count
4456: ,x_msg_data
4457: ,'_PUB');
4458:

Line 4463: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

4459:
4460:
4461:
4462: WHEN OTHERS THEN
4463: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
4464: (l_api_name
4465: ,G_PKG_NAME
4466: ,'OTHERS'
4467: ,x_msg_count

Line 4487: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;

4483: x_msg_count OUT NOCOPY NUMBER,
4484: x_msg_data OUT NOCOPY VARCHAR2,
4485: p_rilv_tbl IN rilv_tbl_type) IS
4486: i NUMBER := 0;
4487: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
4488: --
4489: l_proc varchar2(72) := g_package||'validate_react_interval';
4490: --
4491:

Line 4497: x_return_status := OKC_API.G_RET_STS_SUCCESS;

4493:
4494:
4495:
4496:
4497: x_return_status := OKC_API.G_RET_STS_SUCCESS;
4498: IF p_rilv_tbl.COUNT > 0 THEN
4499: i := p_rilv_tbl.FIRST;
4500: LOOP
4501: validate_react_interval(

Line 4508: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN

4504: x_return_status => l_return_status,
4505: x_msg_count => x_msg_count,
4506: x_msg_data => x_msg_data,
4507: p_rilv_rec => p_rilv_tbl(i));
4508: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
4509: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
4510: x_return_status := l_return_status;
4511: raise G_EXCEPTION_HALT_VALIDATION;
4512: ELSE

Line 4509: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

4505: x_msg_count => x_msg_count,
4506: x_msg_data => x_msg_data,
4507: p_rilv_rec => p_rilv_tbl(i));
4508: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
4509: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
4510: x_return_status := l_return_status;
4511: raise G_EXCEPTION_HALT_VALIDATION;
4512: ELSE
4513: x_return_status := l_return_status;

Line 4533: OKC_API.SET_MESSAGE(

4529:
4530: NULL;
4531: WHEN OTHERS THEN
4532: -- store SQL error message on message stack
4533: OKC_API.SET_MESSAGE(
4534: p_app_name => G_APP_NAME,
4535: p_msg_name => G_UNEXPECTED_ERROR,
4536: p_token1 => G_SQLCODE_TOKEN,
4537: p_token1_value => SQLCODE,

Line 4541: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

4537: p_token1_value => SQLCODE,
4538: p_token2 => G_SQLERRM_TOKEN,
4539: p_token2_value => SQLERRM);
4540: -- notify caller of an error as UNEXPETED error
4541: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
4542:
4543:
4544:
4545: