APPS.OKC_CONDITIONS_PUB dependencies on OKC_API

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

200:
201: l_api_name CONSTANT VARCHAR2(30) := 'create_cond_hdrs';
202: l_return_status VARCHAR2(1);
203: BEGIN
204: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
205: p_init_msg_list,
206: '_PUB',
207: x_return_status);
208: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

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

204: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
205: p_init_msg_list,
206: '_PUB',
207: x_return_status);
208: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
209: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
210: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
211: raise OKC_API.G_EXCEPTION_ERROR;
212: END IF;

Line 209: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

205: p_init_msg_list,
206: '_PUB',
207: x_return_status);
208: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
209: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
210: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
211: raise OKC_API.G_EXCEPTION_ERROR;
212: END IF;
213: -- Call to Complex API procedure

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

206: '_PUB',
207: x_return_status);
208: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
209: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
210: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
211: raise OKC_API.G_EXCEPTION_ERROR;
212: END IF;
213: -- Call to Complex API procedure
214: okc_conditions_pvt.create_cond_hdrs(

Line 211: raise OKC_API.G_EXCEPTION_ERROR;

207: x_return_status);
208: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
209: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
210: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
211: raise OKC_API.G_EXCEPTION_ERROR;
212: END IF;
213: -- Call to Complex API procedure
214: okc_conditions_pvt.create_cond_hdrs(
215: p_api_version,

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

220: p_cnhv_rec,
221: p_cnlv_tbl,
222: x_cnhv_rec,
223: x_cnlv_tbl);
224: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
225: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
226: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
227: raise OKC_API.G_EXCEPTION_ERROR;
228: END IF;

Line 225: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

221: p_cnlv_tbl,
222: x_cnhv_rec,
223: x_cnlv_tbl);
224: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
225: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
226: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
227: raise OKC_API.G_EXCEPTION_ERROR;
228: END IF;
229:

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

222: x_cnhv_rec,
223: x_cnlv_tbl);
224: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
225: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
226: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
227: raise OKC_API.G_EXCEPTION_ERROR;
228: END IF;
229:
230: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

Line 227: raise OKC_API.G_EXCEPTION_ERROR;

223: x_cnlv_tbl);
224: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
225: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
226: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
227: raise OKC_API.G_EXCEPTION_ERROR;
228: END IF;
229:
230: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
231: EXCEPTION

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

226: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
227: raise OKC_API.G_EXCEPTION_ERROR;
228: END IF;
229:
230: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
231: EXCEPTION
232: WHEN OKC_API.G_EXCEPTION_ERROR THEN
233: x_return_status := OKC_API.HANDLE_EXCEPTIONS
234: (l_api_name,

Line 232: WHEN OKC_API.G_EXCEPTION_ERROR THEN

228: END IF;
229:
230: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
231: EXCEPTION
232: WHEN OKC_API.G_EXCEPTION_ERROR THEN
233: x_return_status := OKC_API.HANDLE_EXCEPTIONS
234: (l_api_name,
235: G_PKG_NAME,
236: 'OKC_API.G_RET_STS_ERROR',

Line 233: x_return_status := OKC_API.HANDLE_EXCEPTIONS

229:
230: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
231: EXCEPTION
232: WHEN OKC_API.G_EXCEPTION_ERROR THEN
233: x_return_status := OKC_API.HANDLE_EXCEPTIONS
234: (l_api_name,
235: G_PKG_NAME,
236: 'OKC_API.G_RET_STS_ERROR',
237: x_msg_count,

Line 236: 'OKC_API.G_RET_STS_ERROR',

232: WHEN OKC_API.G_EXCEPTION_ERROR THEN
233: x_return_status := OKC_API.HANDLE_EXCEPTIONS
234: (l_api_name,
235: G_PKG_NAME,
236: 'OKC_API.G_RET_STS_ERROR',
237: x_msg_count,
238: x_msg_data,
239: '_PUB');
240: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

Line 240: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

236: 'OKC_API.G_RET_STS_ERROR',
237: x_msg_count,
238: x_msg_data,
239: '_PUB');
240: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
241: x_return_status := OKC_API.HANDLE_EXCEPTIONS
242: (l_api_name,
243: G_PKG_NAME,
244: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 241: x_return_status := OKC_API.HANDLE_EXCEPTIONS

237: x_msg_count,
238: x_msg_data,
239: '_PUB');
240: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
241: x_return_status := OKC_API.HANDLE_EXCEPTIONS
242: (l_api_name,
243: G_PKG_NAME,
244: 'OKC_API.G_RET_STS_UNEXP_ERROR',
245: x_msg_count,

Line 244: 'OKC_API.G_RET_STS_UNEXP_ERROR',

240: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
241: x_return_status := OKC_API.HANDLE_EXCEPTIONS
242: (l_api_name,
243: G_PKG_NAME,
244: 'OKC_API.G_RET_STS_UNEXP_ERROR',
245: x_msg_count,
246: x_msg_data,
247: '_PUB');
248: WHEN OTHERS THEN

Line 249: x_return_status := OKC_API.HANDLE_EXCEPTIONS

245: x_msg_count,
246: x_msg_data,
247: '_PUB');
248: WHEN OTHERS THEN
249: x_return_status := OKC_API.HANDLE_EXCEPTIONS
250: (l_api_name,
251: G_PKG_NAME,
252: 'OTHERS',
253: x_msg_count,

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

268: x_cnlv_tbl OUT NOCOPY cnlv_tbl_type) IS
269:
270: l_api_version CONSTANT NUMBER := 1;
271: l_api_name CONSTANT VARCHAR2(30) := 'V_update_cond_hdrs';
272: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
273:
274: BEGIN
275: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
276: p_init_msg_list,

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

271: l_api_name CONSTANT VARCHAR2(30) := 'V_update_cond_hdrs';
272: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
273:
274: BEGIN
275: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
276: p_init_msg_list,
277: '_PUB',
278: x_return_status);
279: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

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

275: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
276: p_init_msg_list,
277: '_PUB',
278: x_return_status);
279: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
280: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
281: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
282: raise OKC_API.G_EXCEPTION_ERROR;
283: END IF;

Line 280: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

276: p_init_msg_list,
277: '_PUB',
278: x_return_status);
279: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
280: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
281: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
282: raise OKC_API.G_EXCEPTION_ERROR;
283: END IF;
284:

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

277: '_PUB',
278: x_return_status);
279: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
280: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
281: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
282: raise OKC_API.G_EXCEPTION_ERROR;
283: END IF;
284:
285: --Call to Complex API procedure

Line 282: raise OKC_API.G_EXCEPTION_ERROR;

278: x_return_status);
279: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
280: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
281: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
282: raise OKC_API.G_EXCEPTION_ERROR;
283: END IF;
284:
285: --Call to Complex API procedure
286: okc_conditions_pvt.update_cond_hdrs(

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

292: p_cnhv_rec,
293: p_cnlv_tbl,
294: x_cnhv_rec,
295: x_cnlv_tbl);
296: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
297: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
298: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
299: raise OKC_API.G_EXCEPTION_ERROR;
300: END IF;

Line 297: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

293: p_cnlv_tbl,
294: x_cnhv_rec,
295: x_cnlv_tbl);
296: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
297: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
298: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
299: raise OKC_API.G_EXCEPTION_ERROR;
300: END IF;
301:

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

294: x_cnhv_rec,
295: x_cnlv_tbl);
296: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
297: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
298: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
299: raise OKC_API.G_EXCEPTION_ERROR;
300: END IF;
301:
302: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

Line 299: raise OKC_API.G_EXCEPTION_ERROR;

295: x_cnlv_tbl);
296: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
297: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
298: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
299: raise OKC_API.G_EXCEPTION_ERROR;
300: END IF;
301:
302: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
303: EXCEPTION

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

298: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
299: raise OKC_API.G_EXCEPTION_ERROR;
300: END IF;
301:
302: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
303: EXCEPTION
304: WHEN OKC_API.G_EXCEPTION_ERROR THEN
305: x_return_status := OKC_API.HANDLE_EXCEPTIONS
306: (l_api_name,

Line 304: WHEN OKC_API.G_EXCEPTION_ERROR THEN

300: END IF;
301:
302: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
303: EXCEPTION
304: WHEN OKC_API.G_EXCEPTION_ERROR THEN
305: x_return_status := OKC_API.HANDLE_EXCEPTIONS
306: (l_api_name,
307: G_PKG_NAME,
308: 'OKC_API.G_RET_STS_ERROR',

Line 305: x_return_status := OKC_API.HANDLE_EXCEPTIONS

301:
302: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
303: EXCEPTION
304: WHEN OKC_API.G_EXCEPTION_ERROR THEN
305: x_return_status := OKC_API.HANDLE_EXCEPTIONS
306: (l_api_name,
307: G_PKG_NAME,
308: 'OKC_API.G_RET_STS_ERROR',
309: x_msg_count,

Line 308: 'OKC_API.G_RET_STS_ERROR',

304: WHEN OKC_API.G_EXCEPTION_ERROR THEN
305: x_return_status := OKC_API.HANDLE_EXCEPTIONS
306: (l_api_name,
307: G_PKG_NAME,
308: 'OKC_API.G_RET_STS_ERROR',
309: x_msg_count,
310: x_msg_data,
311: '_PUB');
312: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

Line 312: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

308: 'OKC_API.G_RET_STS_ERROR',
309: x_msg_count,
310: x_msg_data,
311: '_PUB');
312: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
313: x_return_status := OKC_API.HANDLE_EXCEPTIONS
314: (l_api_name,
315: G_PKG_NAME,
316: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 313: x_return_status := OKC_API.HANDLE_EXCEPTIONS

309: x_msg_count,
310: x_msg_data,
311: '_PUB');
312: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
313: x_return_status := OKC_API.HANDLE_EXCEPTIONS
314: (l_api_name,
315: G_PKG_NAME,
316: 'OKC_API.G_RET_STS_UNEXP_ERROR',
317: x_msg_count,

Line 316: 'OKC_API.G_RET_STS_UNEXP_ERROR',

312: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
313: x_return_status := OKC_API.HANDLE_EXCEPTIONS
314: (l_api_name,
315: G_PKG_NAME,
316: 'OKC_API.G_RET_STS_UNEXP_ERROR',
317: x_msg_count,
318: x_msg_data,
319: '_PUB');
320: WHEN OTHERS THEN

Line 321: x_return_status := OKC_API.HANDLE_EXCEPTIONS

317: x_msg_count,
318: x_msg_data,
319: '_PUB');
320: WHEN OTHERS THEN
321: x_return_status := OKC_API.HANDLE_EXCEPTIONS
322: (l_api_name,
323: G_PKG_NAME,
324: 'OTHERS',
325: x_msg_count,

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

338: p_cnlv_tbl IN cnlv_tbl_type) IS
339:
340: l_api_version CONSTANT NUMBER := 1;
341: l_api_name CONSTANT VARCHAR2(30) := 'V_validate_cond_hdrs';
342: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
343:
344: BEGIN
345: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
346: p_init_msg_list,

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

341: l_api_name CONSTANT VARCHAR2(30) := 'V_validate_cond_hdrs';
342: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
343:
344: BEGIN
345: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
346: p_init_msg_list,
347: '_PUB',
348: x_return_status);
349: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

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

345: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
346: p_init_msg_list,
347: '_PUB',
348: x_return_status);
349: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
350: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
351: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
352: raise OKC_API.G_EXCEPTION_ERROR;
353: END IF;

Line 350: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

346: p_init_msg_list,
347: '_PUB',
348: x_return_status);
349: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
350: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
351: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
352: raise OKC_API.G_EXCEPTION_ERROR;
353: END IF;
354:

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

347: '_PUB',
348: x_return_status);
349: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
350: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
351: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
352: raise OKC_API.G_EXCEPTION_ERROR;
353: END IF;
354:
355: okc_conditions_pvt.validate_cond_hdrs(

Line 352: raise OKC_API.G_EXCEPTION_ERROR;

348: x_return_status);
349: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
350: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
351: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
352: raise OKC_API.G_EXCEPTION_ERROR;
353: END IF;
354:
355: okc_conditions_pvt.validate_cond_hdrs(
356: p_api_version,

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

359: x_msg_count,
360: x_msg_data,
361: p_cnhv_rec,
362: p_cnlv_tbl);
363: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
364: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
365: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
366: raise OKC_API.G_EXCEPTION_ERROR;
367: END IF;

Line 364: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

360: x_msg_data,
361: p_cnhv_rec,
362: p_cnlv_tbl);
363: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
364: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
365: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
366: raise OKC_API.G_EXCEPTION_ERROR;
367: END IF;
368:

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

361: p_cnhv_rec,
362: p_cnlv_tbl);
363: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
364: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
365: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
366: raise OKC_API.G_EXCEPTION_ERROR;
367: END IF;
368:
369: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

Line 366: raise OKC_API.G_EXCEPTION_ERROR;

362: p_cnlv_tbl);
363: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
364: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
365: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
366: raise OKC_API.G_EXCEPTION_ERROR;
367: END IF;
368:
369: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
370: EXCEPTION

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

365: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
366: raise OKC_API.G_EXCEPTION_ERROR;
367: END IF;
368:
369: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
370: EXCEPTION
371: WHEN OKC_API.G_EXCEPTION_ERROR THEN
372: x_return_status := OKC_API.HANDLE_EXCEPTIONS
373: (l_api_name,

Line 371: WHEN OKC_API.G_EXCEPTION_ERROR THEN

367: END IF;
368:
369: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
370: EXCEPTION
371: WHEN OKC_API.G_EXCEPTION_ERROR THEN
372: x_return_status := OKC_API.HANDLE_EXCEPTIONS
373: (l_api_name,
374: G_PKG_NAME,
375: 'OKC_API.G_RET_STS_ERROR',

Line 372: x_return_status := OKC_API.HANDLE_EXCEPTIONS

368:
369: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
370: EXCEPTION
371: WHEN OKC_API.G_EXCEPTION_ERROR THEN
372: x_return_status := OKC_API.HANDLE_EXCEPTIONS
373: (l_api_name,
374: G_PKG_NAME,
375: 'OKC_API.G_RET_STS_ERROR',
376: x_msg_count,

Line 375: 'OKC_API.G_RET_STS_ERROR',

371: WHEN OKC_API.G_EXCEPTION_ERROR THEN
372: x_return_status := OKC_API.HANDLE_EXCEPTIONS
373: (l_api_name,
374: G_PKG_NAME,
375: 'OKC_API.G_RET_STS_ERROR',
376: x_msg_count,
377: x_msg_data,
378: '_PUB');
379: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

Line 379: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

375: 'OKC_API.G_RET_STS_ERROR',
376: x_msg_count,
377: x_msg_data,
378: '_PUB');
379: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
380: x_return_status := OKC_API.HANDLE_EXCEPTIONS
381: (l_api_name,
382: G_PKG_NAME,
383: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 380: x_return_status := OKC_API.HANDLE_EXCEPTIONS

376: x_msg_count,
377: x_msg_data,
378: '_PUB');
379: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
380: x_return_status := OKC_API.HANDLE_EXCEPTIONS
381: (l_api_name,
382: G_PKG_NAME,
383: 'OKC_API.G_RET_STS_UNEXP_ERROR',
384: x_msg_count,

Line 383: 'OKC_API.G_RET_STS_UNEXP_ERROR',

379: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
380: x_return_status := OKC_API.HANDLE_EXCEPTIONS
381: (l_api_name,
382: G_PKG_NAME,
383: 'OKC_API.G_RET_STS_UNEXP_ERROR',
384: x_msg_count,
385: x_msg_data,
386: '_PUB');
387: WHEN OTHERS THEN

Line 388: x_return_status := OKC_API.HANDLE_EXCEPTIONS

384: x_msg_count,
385: x_msg_data,
386: '_PUB');
387: WHEN OTHERS THEN
388: x_return_status := OKC_API.HANDLE_EXCEPTIONS
389: (l_api_name,
390: G_PKG_NAME,
391: 'OTHERS',
392: x_msg_count,

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

405: x_cnhv_rec OUT NOCOPY cnhv_rec_type) IS
406:
407: l_api_name CONSTANT VARCHAR2(30) := 'create_cond_hdrs';
408: l_api_version CONSTANT NUMBER := 1.0;
409: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
410: l_cnhv_rec cnhv_rec_type := p_cnhv_rec;
411: BEGIN
412: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
413: g_pkg_name,

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

408: l_api_version CONSTANT NUMBER := 1.0;
409: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
410: l_cnhv_rec cnhv_rec_type := p_cnhv_rec;
411: BEGIN
412: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
413: g_pkg_name,
414: p_init_msg_list,
415: l_api_version,
416: p_api_version,

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

416: p_api_version,
417: '_PUB',
418: x_return_status);
419:
420: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
421: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
422: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
423: RAISE OKC_API.G_EXCEPTION_ERROR;
424: END IF;

Line 421: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

417: '_PUB',
418: x_return_status);
419:
420: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
421: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
422: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
423: RAISE OKC_API.G_EXCEPTION_ERROR;
424: END IF;
425:

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

418: x_return_status);
419:
420: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
421: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
422: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
423: RAISE OKC_API.G_EXCEPTION_ERROR;
424: END IF;
425:
426: -- USER HOOK CALL FOR BEFORE, STARTS

Line 423: RAISE OKC_API.G_EXCEPTION_ERROR;

419:
420: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
421: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
422: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
423: RAISE OKC_API.G_EXCEPTION_ERROR;
424: END IF;
425:
426: -- USER HOOK CALL FOR BEFORE, STARTS
427: g_cnhv_rec := l_cnhv_rec;

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

429: okc_util.call_user_hook(x_return_status => x_return_status,
430: p_package_name => g_pkg_name,
431: p_procedure_name => l_api_name,
432: p_before_after => 'B');
433: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
434: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
435: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
436: RAISE OKC_API.G_EXCEPTION_ERROR;
437: END IF;

Line 434: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

430: p_package_name => g_pkg_name,
431: p_procedure_name => l_api_name,
432: p_before_after => 'B');
433: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
434: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
435: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
436: RAISE OKC_API.G_EXCEPTION_ERROR;
437: END IF;
438:

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

431: p_procedure_name => l_api_name,
432: p_before_after => 'B');
433: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
434: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
435: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
436: RAISE OKC_API.G_EXCEPTION_ERROR;
437: END IF;
438:
439: --get values back from hook call

Line 436: RAISE OKC_API.G_EXCEPTION_ERROR;

432: p_before_after => 'B');
433: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
434: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
435: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
436: RAISE OKC_API.G_EXCEPTION_ERROR;
437: END IF;
438:
439: --get values back from hook call
440: l_cnhv_rec := migrate_cnhv(l_cnhv_rec, g_cnhv_rec);

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

446: x_msg_count => x_msg_count,
447: x_msg_data => x_msg_data,
448: p_cnhv_rec => l_cnhv_rec,
449: x_cnhv_rec => x_cnhv_rec);
450: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
451: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
452: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
453: raise OKC_API.G_EXCEPTION_ERROR;
454: END IF;

Line 451: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

447: x_msg_data => x_msg_data,
448: p_cnhv_rec => l_cnhv_rec,
449: x_cnhv_rec => x_cnhv_rec);
450: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
451: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
452: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
453: raise OKC_API.G_EXCEPTION_ERROR;
454: END IF;
455:

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

448: p_cnhv_rec => l_cnhv_rec,
449: x_cnhv_rec => x_cnhv_rec);
450: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
451: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
452: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
453: raise OKC_API.G_EXCEPTION_ERROR;
454: END IF;
455:
456: --USER HOOK CALL FOR AFTER, STARTS

Line 453: raise OKC_API.G_EXCEPTION_ERROR;

449: x_cnhv_rec => x_cnhv_rec);
450: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
451: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
452: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
453: raise OKC_API.G_EXCEPTION_ERROR;
454: END IF;
455:
456: --USER HOOK CALL FOR AFTER, STARTS
457: g_cnhv_rec := x_cnhv_rec;

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

460: p_package_name => g_pkg_name,
461: p_procedure_name => l_api_name,
462: p_before_after => 'A');
463:
464: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
465: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
466: ELSIF (x_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_procedure_name => l_api_name,
462: p_before_after => 'A');
463:
464: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
465: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
466: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
467: RAISE OKC_API.G_EXCEPTION_ERROR;
468: END IF;
469: --USER HOOK CALL FOR AFTER, ENDS

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

462: p_before_after => 'A');
463:
464: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
465: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
466: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
467: RAISE OKC_API.G_EXCEPTION_ERROR;
468: END IF;
469: --USER HOOK CALL FOR AFTER, ENDS
470:

Line 467: RAISE OKC_API.G_EXCEPTION_ERROR;

463:
464: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
465: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
466: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
467: RAISE OKC_API.G_EXCEPTION_ERROR;
468: END IF;
469: --USER HOOK CALL FOR AFTER, ENDS
470:
471: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

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

467: RAISE OKC_API.G_EXCEPTION_ERROR;
468: END IF;
469: --USER HOOK CALL FOR AFTER, ENDS
470:
471: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
472:
473: EXCEPTION
474: WHEN OKC_API.G_EXCEPTION_ERROR THEN
475: x_return_status := OKC_API.HANDLE_EXCEPTIONS

Line 474: WHEN OKC_API.G_EXCEPTION_ERROR THEN

470:
471: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
472:
473: EXCEPTION
474: WHEN OKC_API.G_EXCEPTION_ERROR THEN
475: x_return_status := OKC_API.HANDLE_EXCEPTIONS
476: (
477: l_api_name,
478: G_PKG_NAME,

Line 475: x_return_status := OKC_API.HANDLE_EXCEPTIONS

471: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
472:
473: EXCEPTION
474: WHEN OKC_API.G_EXCEPTION_ERROR THEN
475: x_return_status := OKC_API.HANDLE_EXCEPTIONS
476: (
477: l_api_name,
478: G_PKG_NAME,
479: 'OKC_API.G_RET_STS_ERROR',

Line 479: 'OKC_API.G_RET_STS_ERROR',

475: x_return_status := OKC_API.HANDLE_EXCEPTIONS
476: (
477: l_api_name,
478: G_PKG_NAME,
479: 'OKC_API.G_RET_STS_ERROR',
480: x_msg_count,
481: x_msg_data,
482: '_PUB'
483: );

Line 485: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

481: x_msg_data,
482: '_PUB'
483: );
484:
485: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
486: x_return_status := OKC_API.HANDLE_EXCEPTIONS
487: (
488: l_api_name,
489: G_PKG_NAME,

Line 486: x_return_status := OKC_API.HANDLE_EXCEPTIONS

482: '_PUB'
483: );
484:
485: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
486: x_return_status := OKC_API.HANDLE_EXCEPTIONS
487: (
488: l_api_name,
489: G_PKG_NAME,
490: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 490: 'OKC_API.G_RET_STS_UNEXP_ERROR',

486: x_return_status := OKC_API.HANDLE_EXCEPTIONS
487: (
488: l_api_name,
489: G_PKG_NAME,
490: 'OKC_API.G_RET_STS_UNEXP_ERROR',
491: x_msg_count,
492: x_msg_data,
493: '_PUB'
494: );

Line 497: x_return_status := OKC_API.HANDLE_EXCEPTIONS

493: '_PUB'
494: );
495:
496: WHEN OTHERS THEN
497: x_return_status := OKC_API.HANDLE_EXCEPTIONS
498: (
499: l_api_name,
500: G_PKG_NAME,
501: 'OTHERS',

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

512: x_msg_data OUT NOCOPY VARCHAR2,
513: p_cnhv_tbl IN cnhv_tbl_type,
514: x_cnhv_tbl OUT NOCOPY cnhv_tbl_type) IS
515:
516: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
517: i NUMBER := 0;
518: BEGIN
519: --Initialize the return status
520: x_return_status := OKC_API.G_RET_STS_SUCCESS;

Line 520: x_return_status := OKC_API.G_RET_STS_SUCCESS;

516: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
517: i NUMBER := 0;
518: BEGIN
519: --Initialize the return status
520: x_return_status := OKC_API.G_RET_STS_SUCCESS;
521:
522: IF p_cnhv_tbl.COUNT > 0 THEN
523: i := p_cnhv_tbl.FIRST;
524: LOOP

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

529: x_msg_count,
530: x_msg_data,
531: p_cnhv_tbl(i),
532: x_cnhv_tbl(i));
533: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
534: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
535: x_return_status := l_return_status;
536: raise G_EXCEPTION_HALT_VALIDATION;
537: ELSE

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

530: x_msg_data,
531: p_cnhv_tbl(i),
532: x_cnhv_tbl(i));
533: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
534: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
535: x_return_status := l_return_status;
536: raise G_EXCEPTION_HALT_VALIDATION;
537: ELSE
538: x_return_status := l_return_status;

Line 550: OKC_API.set_message(p_app_name => g_app_name,

546: WHEN G_EXCEPTION_HALT_VALIDATION THEN
547: NULL;
548:
549: WHEN OTHERS THEN
550: OKC_API.set_message(p_app_name => g_app_name,
551: p_msg_name => g_unexpected_error,
552: p_token1 => g_sqlcode_token,
553: p_token1_value => sqlcode,
554: p_token2 => g_sqlerrm_token,

Line 556: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

552: p_token1 => g_sqlcode_token,
553: p_token1_value => sqlcode,
554: p_token2 => g_sqlerrm_token,
555: p_token2_value => sqlerrm);
556: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
557: END create_cond_hdrs;
558:
559: PROCEDURE lock_cond_hdrs(p_api_version IN NUMBER,
560: p_init_msg_list IN VARCHAR2 ,

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

564: p_cnhv_rec IN cnhv_rec_type) IS
565:
566: l_api_name CONSTANT VARCHAR2(30) := 'lock_cond_hdrs';
567: l_api_version CONSTANT NUMBER := 1.0;
568: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
569: BEGIN
570: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
571: g_pkg_name,
572: p_init_msg_list,

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

566: l_api_name CONSTANT VARCHAR2(30) := 'lock_cond_hdrs';
567: l_api_version CONSTANT NUMBER := 1.0;
568: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
569: BEGIN
570: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
571: g_pkg_name,
572: p_init_msg_list,
573: l_api_version,
574: p_api_version,

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

574: p_api_version,
575: '_PUB',
576: x_return_status);
577:
578: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
579: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
580: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
581: RAISE OKC_API.G_EXCEPTION_ERROR;
582: END IF;

Line 579: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

575: '_PUB',
576: x_return_status);
577:
578: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
579: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
580: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
581: RAISE OKC_API.G_EXCEPTION_ERROR;
582: END IF;
583:

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

576: x_return_status);
577:
578: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
579: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
580: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
581: RAISE OKC_API.G_EXCEPTION_ERROR;
582: END IF;
583:
584: -- Call to procedure of complex API

Line 581: RAISE OKC_API.G_EXCEPTION_ERROR;

577:
578: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
579: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
580: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
581: RAISE OKC_API.G_EXCEPTION_ERROR;
582: END IF;
583:
584: -- Call to procedure of complex API
585: okc_conditions_pvt.lock_cond_hdrs(p_api_version => p_api_version,

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

587: x_return_status => x_return_status,
588: x_msg_count => x_msg_count,
589: x_msg_data => x_msg_data,
590: p_cnhv_rec => p_cnhv_rec);
591: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
592: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
593: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
594: RAISE OKC_API.G_EXCEPTION_ERROR;
595: END IF;

Line 592: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

588: x_msg_count => x_msg_count,
589: x_msg_data => x_msg_data,
590: p_cnhv_rec => p_cnhv_rec);
591: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
592: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
593: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
594: RAISE OKC_API.G_EXCEPTION_ERROR;
595: END IF;
596:

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

589: x_msg_data => x_msg_data,
590: p_cnhv_rec => p_cnhv_rec);
591: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
592: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
593: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
594: RAISE OKC_API.G_EXCEPTION_ERROR;
595: END IF;
596:
597: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

Line 594: RAISE OKC_API.G_EXCEPTION_ERROR;

590: p_cnhv_rec => p_cnhv_rec);
591: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
592: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
593: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
594: RAISE OKC_API.G_EXCEPTION_ERROR;
595: END IF;
596:
597: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
598:

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

593: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
594: RAISE OKC_API.G_EXCEPTION_ERROR;
595: END IF;
596:
597: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
598:
599: EXCEPTION
600: WHEN OKC_API.G_EXCEPTION_ERROR THEN
601: x_return_status := OKC_API.HANDLE_EXCEPTIONS

Line 600: WHEN OKC_API.G_EXCEPTION_ERROR THEN

596:
597: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
598:
599: EXCEPTION
600: WHEN OKC_API.G_EXCEPTION_ERROR THEN
601: x_return_status := OKC_API.HANDLE_EXCEPTIONS
602: (
603: l_api_name,
604: G_PKG_NAME,

Line 601: x_return_status := OKC_API.HANDLE_EXCEPTIONS

597: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
598:
599: EXCEPTION
600: WHEN OKC_API.G_EXCEPTION_ERROR THEN
601: x_return_status := OKC_API.HANDLE_EXCEPTIONS
602: (
603: l_api_name,
604: G_PKG_NAME,
605: 'OKC_API.G_RET_STS_ERROR',

Line 605: 'OKC_API.G_RET_STS_ERROR',

601: x_return_status := OKC_API.HANDLE_EXCEPTIONS
602: (
603: l_api_name,
604: G_PKG_NAME,
605: 'OKC_API.G_RET_STS_ERROR',
606: x_msg_count,
607: x_msg_data,
608: '_PUB'
609: );

Line 611: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

607: x_msg_data,
608: '_PUB'
609: );
610:
611: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
612: x_return_status := OKC_API.HANDLE_EXCEPTIONS
613: (
614: l_api_name,
615: G_PKG_NAME,

Line 612: x_return_status := OKC_API.HANDLE_EXCEPTIONS

608: '_PUB'
609: );
610:
611: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
612: x_return_status := OKC_API.HANDLE_EXCEPTIONS
613: (
614: l_api_name,
615: G_PKG_NAME,
616: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 616: 'OKC_API.G_RET_STS_UNEXP_ERROR',

612: x_return_status := OKC_API.HANDLE_EXCEPTIONS
613: (
614: l_api_name,
615: G_PKG_NAME,
616: 'OKC_API.G_RET_STS_UNEXP_ERROR',
617: x_msg_count,
618: x_msg_data,
619: '_PUB'
620: );

Line 623: x_return_status := OKC_API.HANDLE_EXCEPTIONS

619: '_PUB'
620: );
621:
622: WHEN OTHERS THEN
623: x_return_status := OKC_API.HANDLE_EXCEPTIONS
624: (
625: l_api_name,
626: G_PKG_NAME,
627: 'OTHERS',

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

637: x_msg_count OUT NOCOPY NUMBER,
638: x_msg_data OUT NOCOPY VARCHAR2,
639: p_cnhv_tbl IN cnhv_tbl_type) IS
640:
641: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
642: i NUMBER := 0;
643: BEGIN
644: x_return_status := OKC_API.G_RET_STS_SUCCESS;
645: IF p_cnhv_tbl.COUNT > 0 THEN

Line 644: x_return_status := OKC_API.G_RET_STS_SUCCESS;

640:
641: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
642: i NUMBER := 0;
643: BEGIN
644: x_return_status := OKC_API.G_RET_STS_SUCCESS;
645: IF p_cnhv_tbl.COUNT > 0 THEN
646: i := p_cnhv_tbl.FIRST;
647: LOOP
648: lock_cond_hdrs(

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

651: l_return_status,
652: x_msg_count,
653: x_msg_data,
654: p_cnhv_tbl(i));
655: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
656: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
657: x_return_status := l_return_status;
658: raise G_EXCEPTION_HALT_VALIDATION;
659: ELSE

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

652: x_msg_count,
653: x_msg_data,
654: p_cnhv_tbl(i));
655: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
656: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
657: x_return_status := l_return_status;
658: raise G_EXCEPTION_HALT_VALIDATION;
659: ELSE
660: x_return_status := l_return_status;

Line 672: OKC_API.set_message(p_app_name => g_app_name,

668: WHEN G_EXCEPTION_HALT_VALIDATION THEN
669: NULL;
670:
671: WHEN OTHERS THEN
672: OKC_API.set_message(p_app_name => g_app_name,
673: p_msg_name => g_unexpected_error,
674: p_token1 => g_sqlcode_token,
675: p_token1_value => sqlcode,
676: p_token2 => g_sqlerrm_token,

Line 678: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

674: p_token1 => g_sqlcode_token,
675: p_token1_value => sqlcode,
676: p_token2 => g_sqlerrm_token,
677: p_token2_value => sqlerrm);
678: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
679: END lock_cond_hdrs;
680:
681: PROCEDURE update_cond_hdrs(p_api_version IN NUMBER,
682: p_init_msg_list IN VARCHAR2 ,

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

687: x_cnhv_rec OUT NOCOPY cnhv_rec_type) IS
688:
689: l_api_name CONSTANT VARCHAR2(30) := 'update_cond_hdrs';
690: l_api_version CONSTANT NUMBER := 1.0;
691: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
692: l_cnhv_rec cnhv_rec_type := p_cnhv_rec;
693: BEGIN
694: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
695: g_pkg_name,

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

690: l_api_version CONSTANT NUMBER := 1.0;
691: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
692: l_cnhv_rec cnhv_rec_type := p_cnhv_rec;
693: BEGIN
694: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
695: g_pkg_name,
696: p_init_msg_list,
697: l_api_version,
698: p_api_version,

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

698: p_api_version,
699: '_PUB',
700: x_return_status);
701:
702: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
703: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
704: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
705: RAISE OKC_API.G_EXCEPTION_ERROR;
706: END IF;

Line 703: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

699: '_PUB',
700: x_return_status);
701:
702: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
703: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
704: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
705: RAISE OKC_API.G_EXCEPTION_ERROR;
706: END IF;
707:

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

700: x_return_status);
701:
702: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
703: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
704: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
705: RAISE OKC_API.G_EXCEPTION_ERROR;
706: END IF;
707:
708: -- USER HOOK CALL FOR BEFORE, STARTS

Line 705: RAISE OKC_API.G_EXCEPTION_ERROR;

701:
702: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
703: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
704: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
705: RAISE OKC_API.G_EXCEPTION_ERROR;
706: END IF;
707:
708: -- USER HOOK CALL FOR BEFORE, STARTS
709: g_cnhv_rec := l_cnhv_rec;

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

712: p_package_name => g_pkg_name,
713: p_procedure_name => l_api_name,
714: p_before_after => 'B');
715:
716: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
717: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
718: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
719: RAISE OKC_API.G_EXCEPTION_ERROR;
720: END IF;

Line 717: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

713: p_procedure_name => l_api_name,
714: p_before_after => 'B');
715:
716: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
717: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
718: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
719: RAISE OKC_API.G_EXCEPTION_ERROR;
720: END IF;
721:

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

714: p_before_after => 'B');
715:
716: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
717: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
718: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
719: RAISE OKC_API.G_EXCEPTION_ERROR;
720: END IF;
721:
722: --get values back from hook call

Line 719: RAISE OKC_API.G_EXCEPTION_ERROR;

715:
716: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
717: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
718: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
719: RAISE OKC_API.G_EXCEPTION_ERROR;
720: END IF;
721:
722: --get values back from hook call
723: l_cnhv_rec := migrate_cnhv(l_cnhv_rec, g_cnhv_rec);

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

729: x_msg_count => x_msg_count,
730: x_msg_data => x_msg_data,
731: p_cnhv_rec => l_cnhv_rec,
732: x_cnhv_rec => x_cnhv_rec);
733: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
734: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
735: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
736: RAISE OKC_API.G_EXCEPTION_ERROR;
737: END IF;

Line 734: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

730: x_msg_data => x_msg_data,
731: p_cnhv_rec => l_cnhv_rec,
732: x_cnhv_rec => x_cnhv_rec);
733: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
734: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
735: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
736: RAISE OKC_API.G_EXCEPTION_ERROR;
737: END IF;
738:

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

731: p_cnhv_rec => l_cnhv_rec,
732: x_cnhv_rec => x_cnhv_rec);
733: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
734: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
735: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
736: RAISE OKC_API.G_EXCEPTION_ERROR;
737: END IF;
738:
739: --USER HOOK CALL FOR AFTER, STARTS

Line 736: RAISE OKC_API.G_EXCEPTION_ERROR;

732: x_cnhv_rec => x_cnhv_rec);
733: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
734: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
735: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
736: RAISE OKC_API.G_EXCEPTION_ERROR;
737: END IF;
738:
739: --USER HOOK CALL FOR AFTER, STARTS
740: g_cnhv_rec := x_cnhv_rec;

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

743: p_package_name => g_pkg_name,
744: p_procedure_name => l_api_name,
745: p_before_after => 'A');
746:
747: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
748: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
749: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
750: RAISE OKC_API.G_EXCEPTION_ERROR;
751: END IF;

Line 748: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

744: p_procedure_name => l_api_name,
745: p_before_after => 'A');
746:
747: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
748: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
749: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
750: RAISE OKC_API.G_EXCEPTION_ERROR;
751: END IF;
752: --USER HOOK CALL FOR AFTER, ENDS

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

745: p_before_after => 'A');
746:
747: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
748: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
749: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
750: RAISE OKC_API.G_EXCEPTION_ERROR;
751: END IF;
752: --USER HOOK CALL FOR AFTER, ENDS
753:

Line 750: RAISE OKC_API.G_EXCEPTION_ERROR;

746:
747: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
748: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
749: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
750: RAISE OKC_API.G_EXCEPTION_ERROR;
751: END IF;
752: --USER HOOK CALL FOR AFTER, ENDS
753:
754: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

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

750: RAISE OKC_API.G_EXCEPTION_ERROR;
751: END IF;
752: --USER HOOK CALL FOR AFTER, ENDS
753:
754: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
755:
756: EXCEPTION
757: WHEN OKC_API.G_EXCEPTION_ERROR THEN
758: x_return_status := OKC_API.HANDLE_EXCEPTIONS

Line 757: WHEN OKC_API.G_EXCEPTION_ERROR THEN

753:
754: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
755:
756: EXCEPTION
757: WHEN OKC_API.G_EXCEPTION_ERROR THEN
758: x_return_status := OKC_API.HANDLE_EXCEPTIONS
759: (
760: l_api_name,
761: G_PKG_NAME,

Line 758: x_return_status := OKC_API.HANDLE_EXCEPTIONS

754: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
755:
756: EXCEPTION
757: WHEN OKC_API.G_EXCEPTION_ERROR THEN
758: x_return_status := OKC_API.HANDLE_EXCEPTIONS
759: (
760: l_api_name,
761: G_PKG_NAME,
762: 'OKC_API.G_RET_STS_ERROR',

Line 762: 'OKC_API.G_RET_STS_ERROR',

758: x_return_status := OKC_API.HANDLE_EXCEPTIONS
759: (
760: l_api_name,
761: G_PKG_NAME,
762: 'OKC_API.G_RET_STS_ERROR',
763: x_msg_count,
764: x_msg_data,
765: '_PUB'
766: );

Line 768: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

764: x_msg_data,
765: '_PUB'
766: );
767:
768: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
769: x_return_status := OKC_API.HANDLE_EXCEPTIONS
770: (
771: l_api_name,
772: G_PKG_NAME,

Line 769: x_return_status := OKC_API.HANDLE_EXCEPTIONS

765: '_PUB'
766: );
767:
768: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
769: x_return_status := OKC_API.HANDLE_EXCEPTIONS
770: (
771: l_api_name,
772: G_PKG_NAME,
773: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 773: 'OKC_API.G_RET_STS_UNEXP_ERROR',

769: x_return_status := OKC_API.HANDLE_EXCEPTIONS
770: (
771: l_api_name,
772: G_PKG_NAME,
773: 'OKC_API.G_RET_STS_UNEXP_ERROR',
774: x_msg_count,
775: x_msg_data,
776: '_PUB'
777: );

Line 780: x_return_status := OKC_API.HANDLE_EXCEPTIONS

776: '_PUB'
777: );
778:
779: WHEN OTHERS THEN
780: x_return_status := OKC_API.HANDLE_EXCEPTIONS
781: (
782: l_api_name,
783: G_PKG_NAME,
784: 'OTHERS',

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

796: x_msg_data OUT NOCOPY VARCHAR2,
797: p_cnhv_tbl IN cnhv_tbl_type,
798: x_cnhv_tbl OUT NOCOPY cnhv_tbl_type) IS
799:
800: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
801: i NUMBER := 0;
802: BEGIN
803: x_return_status := OKC_API.G_RET_STS_SUCCESS;
804: IF p_cnhv_tbl.COUNT > 0 THEN

Line 803: x_return_status := OKC_API.G_RET_STS_SUCCESS;

799:
800: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
801: i NUMBER := 0;
802: BEGIN
803: x_return_status := OKC_API.G_RET_STS_SUCCESS;
804: IF p_cnhv_tbl.COUNT > 0 THEN
805: i := p_cnhv_tbl.FIRST;
806: LOOP
807: update_cond_hdrs(

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

811: x_msg_count,
812: x_msg_data,
813: p_cnhv_tbl(i),
814: x_cnhv_tbl(i));
815: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
816: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
817: x_return_status := l_return_status;
818: raise G_EXCEPTION_HALT_VALIDATION;
819: ELSE

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

812: x_msg_data,
813: p_cnhv_tbl(i),
814: x_cnhv_tbl(i));
815: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
816: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
817: x_return_status := l_return_status;
818: raise G_EXCEPTION_HALT_VALIDATION;
819: ELSE
820: x_return_status := l_return_status;

Line 832: OKC_API.set_message(p_app_name => g_app_name,

828: WHEN G_EXCEPTION_HALT_VALIDATION THEN
829: NULL;
830:
831: WHEN OTHERS THEN
832: OKC_API.set_message(p_app_name => g_app_name,
833: p_msg_name => g_unexpected_error,
834: p_token1 => g_sqlcode_token,
835: p_token1_value => sqlcode,
836: p_token2 => g_sqlerrm_token,

Line 838: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

834: p_token1 => g_sqlcode_token,
835: p_token1_value => sqlcode,
836: p_token2 => g_sqlerrm_token,
837: p_token2_value => sqlerrm);
838: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
839: END update_cond_hdrs;
840:
841: PROCEDURE delete_cond_hdrs(p_api_version IN NUMBER,
842: p_init_msg_list IN VARCHAR2 ,

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

846: p_cnhv_rec IN cnhv_rec_type) IS
847:
848: l_api_name CONSTANT VARCHAR2(30) := 'delete_cond_hdrs';
849: l_api_version CONSTANT NUMBER := 1.0;
850: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
851: l_cnhv_rec cnhv_rec_type := p_cnhv_rec;
852: BEGIN
853: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
854: g_pkg_name,

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

849: l_api_version CONSTANT NUMBER := 1.0;
850: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
851: l_cnhv_rec cnhv_rec_type := p_cnhv_rec;
852: BEGIN
853: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
854: g_pkg_name,
855: p_init_msg_list,
856: l_api_version,
857: p_api_version,

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

857: p_api_version,
858: '_PUB',
859: x_return_status);
860:
861: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
862: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
863: ELSIF (l_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: '_PUB',
859: x_return_status);
860:
861: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
862: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
863: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
864: RAISE OKC_API.G_EXCEPTION_ERROR;
865: END IF;
866:

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

859: x_return_status);
860:
861: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
862: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
863: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
864: RAISE OKC_API.G_EXCEPTION_ERROR;
865: END IF;
866:
867: -- USER HOOK CALL FOR BEFORE, STARTS

Line 864: RAISE OKC_API.G_EXCEPTION_ERROR;

860:
861: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
862: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
863: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
864: RAISE OKC_API.G_EXCEPTION_ERROR;
865: END IF;
866:
867: -- USER HOOK CALL FOR BEFORE, STARTS
868: g_cnhv_rec := l_cnhv_rec;

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

870: okc_util.call_user_hook(x_return_status => x_return_status,
871: p_package_name => g_pkg_name,
872: p_procedure_name => l_api_name,
873: p_before_after => 'B');
874: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
875: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
876: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
877: RAISE OKC_API.G_EXCEPTION_ERROR;
878: END IF;

Line 875: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

871: p_package_name => g_pkg_name,
872: p_procedure_name => l_api_name,
873: p_before_after => 'B');
874: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
875: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
876: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
877: RAISE OKC_API.G_EXCEPTION_ERROR;
878: END IF;
879:

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

872: p_procedure_name => l_api_name,
873: p_before_after => 'B');
874: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
875: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
876: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
877: RAISE OKC_API.G_EXCEPTION_ERROR;
878: END IF;
879:
880: --get values back from hook call

Line 877: RAISE OKC_API.G_EXCEPTION_ERROR;

873: p_before_after => 'B');
874: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
875: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
876: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
877: RAISE OKC_API.G_EXCEPTION_ERROR;
878: END IF;
879:
880: --get values back from hook call
881: l_cnhv_rec := migrate_cnhv(l_cnhv_rec, g_cnhv_rec);

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

886: x_return_status => x_return_status,
887: x_msg_count => x_msg_count,
888: x_msg_data => x_msg_data,
889: p_cnhv_rec => l_cnhv_rec);
890: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
891: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
892: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
893: RAISE OKC_API.G_EXCEPTION_ERROR;
894: END IF;

Line 891: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

887: x_msg_count => x_msg_count,
888: x_msg_data => x_msg_data,
889: p_cnhv_rec => l_cnhv_rec);
890: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
891: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
892: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
893: RAISE OKC_API.G_EXCEPTION_ERROR;
894: END IF;
895:

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

888: x_msg_data => x_msg_data,
889: p_cnhv_rec => l_cnhv_rec);
890: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
891: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
892: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
893: RAISE OKC_API.G_EXCEPTION_ERROR;
894: END IF;
895:
896: --USER HOOK CALL FOR AFTER, STARTS

Line 893: RAISE OKC_API.G_EXCEPTION_ERROR;

889: p_cnhv_rec => l_cnhv_rec);
890: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
891: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
892: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
893: RAISE OKC_API.G_EXCEPTION_ERROR;
894: END IF;
895:
896: --USER HOOK CALL FOR AFTER, STARTS
897: okc_util.call_user_hook(x_return_status => x_return_status,

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

898: p_package_name => g_pkg_name,
899: p_procedure_name => l_api_name,
900: p_before_after => 'A');
901:
902: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
903: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
904: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
905: RAISE OKC_API.G_EXCEPTION_ERROR;
906: END IF;

Line 903: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

899: p_procedure_name => l_api_name,
900: p_before_after => 'A');
901:
902: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
903: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
904: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
905: RAISE OKC_API.G_EXCEPTION_ERROR;
906: END IF;
907: --USER HOOK CALL FOR AFTER, ENDS

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

900: p_before_after => 'A');
901:
902: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
903: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
904: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
905: RAISE OKC_API.G_EXCEPTION_ERROR;
906: END IF;
907: --USER HOOK CALL FOR AFTER, ENDS
908:

Line 905: RAISE OKC_API.G_EXCEPTION_ERROR;

901:
902: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
903: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
904: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
905: RAISE OKC_API.G_EXCEPTION_ERROR;
906: END IF;
907: --USER HOOK CALL FOR AFTER, ENDS
908:
909: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

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

905: RAISE OKC_API.G_EXCEPTION_ERROR;
906: END IF;
907: --USER HOOK CALL FOR AFTER, ENDS
908:
909: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
910:
911: EXCEPTION
912: WHEN OKC_API.G_EXCEPTION_ERROR THEN
913: x_return_status := OKC_API.HANDLE_EXCEPTIONS

Line 912: WHEN OKC_API.G_EXCEPTION_ERROR THEN

908:
909: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
910:
911: EXCEPTION
912: WHEN OKC_API.G_EXCEPTION_ERROR THEN
913: x_return_status := OKC_API.HANDLE_EXCEPTIONS
914: (
915: l_api_name,
916: G_PKG_NAME,

Line 913: x_return_status := OKC_API.HANDLE_EXCEPTIONS

909: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
910:
911: EXCEPTION
912: WHEN OKC_API.G_EXCEPTION_ERROR THEN
913: x_return_status := OKC_API.HANDLE_EXCEPTIONS
914: (
915: l_api_name,
916: G_PKG_NAME,
917: 'OKC_API.G_RET_STS_ERROR',

Line 917: 'OKC_API.G_RET_STS_ERROR',

913: x_return_status := OKC_API.HANDLE_EXCEPTIONS
914: (
915: l_api_name,
916: G_PKG_NAME,
917: 'OKC_API.G_RET_STS_ERROR',
918: x_msg_count,
919: x_msg_data,
920: '_PUB'
921: );

Line 923: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

919: x_msg_data,
920: '_PUB'
921: );
922:
923: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
924: x_return_status := OKC_API.HANDLE_EXCEPTIONS
925: (
926: l_api_name,
927: G_PKG_NAME,

Line 924: x_return_status := OKC_API.HANDLE_EXCEPTIONS

920: '_PUB'
921: );
922:
923: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
924: x_return_status := OKC_API.HANDLE_EXCEPTIONS
925: (
926: l_api_name,
927: G_PKG_NAME,
928: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 928: 'OKC_API.G_RET_STS_UNEXP_ERROR',

924: x_return_status := OKC_API.HANDLE_EXCEPTIONS
925: (
926: l_api_name,
927: G_PKG_NAME,
928: 'OKC_API.G_RET_STS_UNEXP_ERROR',
929: x_msg_count,
930: x_msg_data,
931: '_PUB'
932: );

Line 935: x_return_status := OKC_API.HANDLE_EXCEPTIONS

931: '_PUB'
932: );
933:
934: WHEN OTHERS THEN
935: x_return_status := OKC_API.HANDLE_EXCEPTIONS
936: (
937: l_api_name,
938: G_PKG_NAME,
939: 'OTHERS',

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

949: x_msg_count OUT NOCOPY NUMBER,
950: x_msg_data OUT NOCOPY VARCHAR2,
951: p_cnhv_tbl IN cnhv_tbl_type) IS
952:
953: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
954: i NUMBER := 0;
955: BEGIN
956: x_return_status := OKC_API.G_RET_STS_SUCCESS;
957: IF p_cnhv_tbl.COUNT > 0 THEN

Line 956: x_return_status := OKC_API.G_RET_STS_SUCCESS;

952:
953: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
954: i NUMBER := 0;
955: BEGIN
956: x_return_status := OKC_API.G_RET_STS_SUCCESS;
957: IF p_cnhv_tbl.COUNT > 0 THEN
958: i := p_cnhv_tbl.FIRST;
959: LOOP
960: delete_cond_hdrs(

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

963: l_return_status,
964: x_msg_count,
965: x_msg_data,
966: p_cnhv_tbl(i));
967: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
968: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
969: x_return_status := l_return_status;
970: raise G_EXCEPTION_HALT_VALIDATION;
971: ELSE

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

964: x_msg_count,
965: x_msg_data,
966: p_cnhv_tbl(i));
967: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
968: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
969: x_return_status := l_return_status;
970: raise G_EXCEPTION_HALT_VALIDATION;
971: ELSE
972: x_return_status := l_return_status;

Line 984: OKC_API.set_message(p_app_name => g_app_name,

980: WHEN G_EXCEPTION_HALT_VALIDATION THEN
981: NULL;
982:
983: WHEN OTHERS THEN
984: OKC_API.set_message(p_app_name => g_app_name,
985: p_msg_name => g_unexpected_error,
986: p_token1 => g_sqlcode_token,
987: p_token1_value => sqlcode,
988: p_token2 => g_sqlerrm_token,

Line 990: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

986: p_token1 => g_sqlcode_token,
987: p_token1_value => sqlcode,
988: p_token2 => g_sqlerrm_token,
989: p_token2_value => sqlerrm);
990: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
991: END delete_cond_hdrs;
992:
993: PROCEDURE validate_cond_hdrs(p_api_version IN NUMBER,
994: p_init_msg_list IN VARCHAR2 ,

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

998: p_cnhv_rec IN cnhv_rec_type) IS
999:
1000: l_api_name CONSTANT VARCHAR2(30) := 'validate_cond_hdrs';
1001: l_api_version CONSTANT NUMBER := 1.0;
1002: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1003: l_cnhv_rec cnhv_rec_type := p_cnhv_rec;
1004: BEGIN
1005: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
1006: g_pkg_name,

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

1001: l_api_version CONSTANT NUMBER := 1.0;
1002: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1003: l_cnhv_rec cnhv_rec_type := p_cnhv_rec;
1004: BEGIN
1005: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
1006: g_pkg_name,
1007: p_init_msg_list,
1008: l_api_version,
1009: p_api_version,

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

1009: p_api_version,
1010: '_PUB',
1011: x_return_status);
1012:
1013: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1014: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1015: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1016: RAISE OKC_API.G_EXCEPTION_ERROR;
1017: END IF;

Line 1014: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1010: '_PUB',
1011: x_return_status);
1012:
1013: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1014: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1015: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1016: RAISE OKC_API.G_EXCEPTION_ERROR;
1017: END IF;
1018:

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

1011: x_return_status);
1012:
1013: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1014: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1015: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1016: RAISE OKC_API.G_EXCEPTION_ERROR;
1017: END IF;
1018:
1019: -- USER HOOK CALL FOR BEFORE, STARTS

Line 1016: RAISE OKC_API.G_EXCEPTION_ERROR;

1012:
1013: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1014: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1015: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1016: RAISE OKC_API.G_EXCEPTION_ERROR;
1017: END IF;
1018:
1019: -- USER HOOK CALL FOR BEFORE, STARTS
1020: g_cnhv_rec := l_cnhv_rec;

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

1023: p_package_name => g_pkg_name,
1024: p_procedure_name => l_api_name,
1025: p_before_after => 'B');
1026:
1027: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1028: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1029: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1030: RAISE OKC_API.G_EXCEPTION_ERROR;
1031: END IF;

Line 1028: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1024: p_procedure_name => l_api_name,
1025: p_before_after => 'B');
1026:
1027: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1028: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1029: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1030: RAISE OKC_API.G_EXCEPTION_ERROR;
1031: END IF;
1032:

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

1025: p_before_after => 'B');
1026:
1027: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1028: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1029: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1030: RAISE OKC_API.G_EXCEPTION_ERROR;
1031: END IF;
1032:
1033: --get values back from hook call

Line 1030: RAISE OKC_API.G_EXCEPTION_ERROR;

1026:
1027: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1028: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1029: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1030: RAISE OKC_API.G_EXCEPTION_ERROR;
1031: END IF;
1032:
1033: --get values back from hook call
1034: l_cnhv_rec := migrate_cnhv(l_cnhv_rec, g_cnhv_rec);

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

1039: x_return_status => x_return_status,
1040: x_msg_count => x_msg_count,
1041: x_msg_data => x_msg_data,
1042: p_cnhv_rec => l_cnhv_rec);
1043: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1044: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1045: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1046: RAISE OKC_API.G_EXCEPTION_ERROR;
1047: END IF;

Line 1044: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1040: x_msg_count => x_msg_count,
1041: x_msg_data => x_msg_data,
1042: p_cnhv_rec => l_cnhv_rec);
1043: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1044: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1045: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1046: RAISE OKC_API.G_EXCEPTION_ERROR;
1047: END IF;
1048:

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

1041: x_msg_data => x_msg_data,
1042: p_cnhv_rec => l_cnhv_rec);
1043: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1044: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1045: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1046: RAISE OKC_API.G_EXCEPTION_ERROR;
1047: END IF;
1048:
1049: --USER HOOK CALL FOR AFTER, STARTS

Line 1046: RAISE OKC_API.G_EXCEPTION_ERROR;

1042: p_cnhv_rec => l_cnhv_rec);
1043: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1044: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1045: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1046: RAISE OKC_API.G_EXCEPTION_ERROR;
1047: END IF;
1048:
1049: --USER HOOK CALL FOR AFTER, STARTS
1050:

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

1052: p_package_name => g_pkg_name,
1053: p_procedure_name => l_api_name,
1054: p_before_after => 'A');
1055:
1056: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1057: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1058: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1059: RAISE OKC_API.G_EXCEPTION_ERROR;
1060: END IF;

Line 1057: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1053: p_procedure_name => l_api_name,
1054: p_before_after => 'A');
1055:
1056: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1057: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1058: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1059: RAISE OKC_API.G_EXCEPTION_ERROR;
1060: END IF;
1061: --USER HOOK CALL FOR AFTER, ENDS

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

1054: p_before_after => 'A');
1055:
1056: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1057: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1058: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1059: RAISE OKC_API.G_EXCEPTION_ERROR;
1060: END IF;
1061: --USER HOOK CALL FOR AFTER, ENDS
1062:

Line 1059: RAISE OKC_API.G_EXCEPTION_ERROR;

1055:
1056: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1057: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1058: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1059: RAISE OKC_API.G_EXCEPTION_ERROR;
1060: END IF;
1061: --USER HOOK CALL FOR AFTER, ENDS
1062:
1063: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

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

1059: RAISE OKC_API.G_EXCEPTION_ERROR;
1060: END IF;
1061: --USER HOOK CALL FOR AFTER, ENDS
1062:
1063: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1064: EXCEPTION
1065: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1066: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1067: (

Line 1065: WHEN OKC_API.G_EXCEPTION_ERROR THEN

1061: --USER HOOK CALL FOR AFTER, ENDS
1062:
1063: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1064: EXCEPTION
1065: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1066: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1067: (
1068: l_api_name,
1069: G_PKG_NAME,

Line 1066: x_return_status := OKC_API.HANDLE_EXCEPTIONS

1062:
1063: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1064: EXCEPTION
1065: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1066: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1067: (
1068: l_api_name,
1069: G_PKG_NAME,
1070: 'OKC_API.G_RET_STS_ERROR',

Line 1070: 'OKC_API.G_RET_STS_ERROR',

1066: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1067: (
1068: l_api_name,
1069: G_PKG_NAME,
1070: 'OKC_API.G_RET_STS_ERROR',
1071: x_msg_count,
1072: x_msg_data,
1073: '_PUB'
1074: );

Line 1076: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

1072: x_msg_data,
1073: '_PUB'
1074: );
1075:
1076: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1077: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1078: (
1079: l_api_name,
1080: G_PKG_NAME,

Line 1077: x_return_status := OKC_API.HANDLE_EXCEPTIONS

1073: '_PUB'
1074: );
1075:
1076: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1077: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1078: (
1079: l_api_name,
1080: G_PKG_NAME,
1081: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 1081: 'OKC_API.G_RET_STS_UNEXP_ERROR',

1077: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1078: (
1079: l_api_name,
1080: G_PKG_NAME,
1081: 'OKC_API.G_RET_STS_UNEXP_ERROR',
1082: x_msg_count,
1083: x_msg_data,
1084: '_PUB'
1085: );

Line 1088: x_return_status := OKC_API.HANDLE_EXCEPTIONS

1084: '_PUB'
1085: );
1086:
1087: WHEN OTHERS THEN
1088: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1089: (
1090: l_api_name,
1091: G_PKG_NAME,
1092: 'OTHERS',

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

1101: x_return_status OUT NOCOPY VARCHAR2,
1102: x_msg_count OUT NOCOPY NUMBER,
1103: x_msg_data OUT NOCOPY VARCHAR2,
1104: p_cnhv_tbl IN cnhv_tbl_type) IS
1105: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1106: i NUMBER := 0;
1107: BEGIN
1108: x_return_status := OKC_API.G_RET_STS_SUCCESS;
1109: IF p_cnhv_tbl.COUNT > 0 THEN

Line 1108: x_return_status := OKC_API.G_RET_STS_SUCCESS;

1104: p_cnhv_tbl IN cnhv_tbl_type) IS
1105: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1106: i NUMBER := 0;
1107: BEGIN
1108: x_return_status := OKC_API.G_RET_STS_SUCCESS;
1109: IF p_cnhv_tbl.COUNT > 0 THEN
1110: i := p_cnhv_tbl.FIRST;
1111: LOOP
1112: validate_cond_hdrs(

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

1115: l_return_status,
1116: x_msg_count,
1117: x_msg_data,
1118: p_cnhv_tbl(i));
1119: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1120: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1121: x_return_status := l_return_status;
1122: raise G_EXCEPTION_HALT_VALIDATION;
1123: ELSE

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

1116: x_msg_count,
1117: x_msg_data,
1118: p_cnhv_tbl(i));
1119: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1120: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1121: x_return_status := l_return_status;
1122: raise G_EXCEPTION_HALT_VALIDATION;
1123: ELSE
1124: x_return_status := l_return_status;

Line 1136: OKC_API.set_message(p_app_name => g_app_name,

1132: WHEN G_EXCEPTION_HALT_VALIDATION THEN
1133: NULL;
1134:
1135: WHEN OTHERS THEN
1136: OKC_API.set_message(p_app_name => g_app_name,
1137: p_msg_name => g_unexpected_error,
1138: p_token1 => g_sqlcode_token,
1139: p_token1_value => sqlcode,
1140: p_token2 => g_sqlerrm_token,

Line 1142: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

1138: p_token1 => g_sqlcode_token,
1139: p_token1_value => sqlcode,
1140: p_token2 => g_sqlerrm_token,
1141: p_token2_value => sqlerrm);
1142: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
1143: END validate_cond_hdrs;
1144:
1145: --Procedures for condition lines
1146:

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

1153: x_cnlv_rec OUT NOCOPY cnlv_rec_type) IS
1154:
1155: l_api_name CONSTANT VARCHAR2(30) := 'create_cond_lines';
1156: l_api_version CONSTANT NUMBER := 1.0;
1157: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1158: l_cnlv_rec cnlv_rec_type := p_cnlv_rec;
1159: BEGIN
1160: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
1161: g_pkg_name,

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

1156: l_api_version CONSTANT NUMBER := 1.0;
1157: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1158: l_cnlv_rec cnlv_rec_type := p_cnlv_rec;
1159: BEGIN
1160: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
1161: g_pkg_name,
1162: p_init_msg_list,
1163: l_api_version,
1164: p_api_version,

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

1164: p_api_version,
1165: '_PUB',
1166: x_return_status);
1167:
1168: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1169: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1170: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1171: RAISE OKC_API.G_EXCEPTION_ERROR;
1172: END IF;

Line 1169: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1165: '_PUB',
1166: x_return_status);
1167:
1168: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1169: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1170: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1171: RAISE OKC_API.G_EXCEPTION_ERROR;
1172: END IF;
1173:

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

1166: x_return_status);
1167:
1168: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1169: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1170: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1171: RAISE OKC_API.G_EXCEPTION_ERROR;
1172: END IF;
1173:
1174: -- USER HOOK CALL FOR BEFORE, STARTS

Line 1171: RAISE OKC_API.G_EXCEPTION_ERROR;

1167:
1168: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1169: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1170: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1171: RAISE OKC_API.G_EXCEPTION_ERROR;
1172: END IF;
1173:
1174: -- USER HOOK CALL FOR BEFORE, STARTS
1175: g_cnlv_rec := l_cnlv_rec;

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

1178: p_package_name => g_pkg_name,
1179: p_procedure_name => l_api_name,
1180: p_before_after => 'B');
1181:
1182: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1183: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1184: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1185: RAISE OKC_API.G_EXCEPTION_ERROR;
1186: END IF;

Line 1183: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1179: p_procedure_name => l_api_name,
1180: p_before_after => 'B');
1181:
1182: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1183: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1184: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1185: RAISE OKC_API.G_EXCEPTION_ERROR;
1186: END IF;
1187:

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

1180: p_before_after => 'B');
1181:
1182: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1183: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1184: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1185: RAISE OKC_API.G_EXCEPTION_ERROR;
1186: END IF;
1187:
1188: --get values back from hook call

Line 1185: RAISE OKC_API.G_EXCEPTION_ERROR;

1181:
1182: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1183: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1184: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1185: RAISE OKC_API.G_EXCEPTION_ERROR;
1186: END IF;
1187:
1188: --get values back from hook call
1189: l_cnlv_rec := migrate_cnlv(l_cnlv_rec, g_cnlv_rec);

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

1194: x_msg_count => x_msg_count,
1195: x_msg_data => x_msg_data,
1196: p_cnlv_rec => l_cnlv_rec,
1197: x_cnlv_rec => x_cnlv_rec);
1198: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1199: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1200: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1201: RAISE OKC_API.G_EXCEPTION_ERROR;
1202: END IF;

Line 1199: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1195: x_msg_data => x_msg_data,
1196: p_cnlv_rec => l_cnlv_rec,
1197: x_cnlv_rec => x_cnlv_rec);
1198: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1199: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1200: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1201: RAISE OKC_API.G_EXCEPTION_ERROR;
1202: END IF;
1203:

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

1196: p_cnlv_rec => l_cnlv_rec,
1197: x_cnlv_rec => x_cnlv_rec);
1198: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1199: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1200: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1201: RAISE OKC_API.G_EXCEPTION_ERROR;
1202: END IF;
1203:
1204: --USER HOOK CALL FOR AFTER, STARTS

Line 1201: RAISE OKC_API.G_EXCEPTION_ERROR;

1197: x_cnlv_rec => x_cnlv_rec);
1198: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1199: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1200: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1201: RAISE OKC_API.G_EXCEPTION_ERROR;
1202: END IF;
1203:
1204: --USER HOOK CALL FOR AFTER, STARTS
1205: g_cnlv_rec := x_cnlv_rec;

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

1208: p_package_name => g_pkg_name,
1209: p_procedure_name => l_api_name,
1210: p_before_after => 'A');
1211:
1212: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1213: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1214: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1215: RAISE OKC_API.G_EXCEPTION_ERROR;
1216: END IF;

Line 1213: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1209: p_procedure_name => l_api_name,
1210: p_before_after => 'A');
1211:
1212: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1213: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1214: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1215: RAISE OKC_API.G_EXCEPTION_ERROR;
1216: END IF;
1217: --USER HOOK CALL FOR AFTER, ENDS

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

1210: p_before_after => 'A');
1211:
1212: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1213: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1214: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1215: RAISE OKC_API.G_EXCEPTION_ERROR;
1216: END IF;
1217: --USER HOOK CALL FOR AFTER, ENDS
1218:

Line 1215: RAISE OKC_API.G_EXCEPTION_ERROR;

1211:
1212: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1213: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1214: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1215: RAISE OKC_API.G_EXCEPTION_ERROR;
1216: END IF;
1217: --USER HOOK CALL FOR AFTER, ENDS
1218:
1219: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

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

1215: RAISE OKC_API.G_EXCEPTION_ERROR;
1216: END IF;
1217: --USER HOOK CALL FOR AFTER, ENDS
1218:
1219: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1220:
1221: EXCEPTION
1222: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1223: x_return_status := OKC_API.HANDLE_EXCEPTIONS

Line 1222: WHEN OKC_API.G_EXCEPTION_ERROR THEN

1218:
1219: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1220:
1221: EXCEPTION
1222: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1223: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1224: (
1225: l_api_name,
1226: G_PKG_NAME,

Line 1223: x_return_status := OKC_API.HANDLE_EXCEPTIONS

1219: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1220:
1221: EXCEPTION
1222: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1223: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1224: (
1225: l_api_name,
1226: G_PKG_NAME,
1227: 'OKC_API.G_RET_STS_ERROR',

Line 1227: 'OKC_API.G_RET_STS_ERROR',

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

Line 1233: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

1229: x_msg_data,
1230: '_PUB'
1231: );
1232:
1233: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1234: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1235: (
1236: l_api_name,
1237: G_PKG_NAME,

Line 1234: x_return_status := OKC_API.HANDLE_EXCEPTIONS

1230: '_PUB'
1231: );
1232:
1233: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1234: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1235: (
1236: l_api_name,
1237: G_PKG_NAME,
1238: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 1238: 'OKC_API.G_RET_STS_UNEXP_ERROR',

1234: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1235: (
1236: l_api_name,
1237: G_PKG_NAME,
1238: 'OKC_API.G_RET_STS_UNEXP_ERROR',
1239: x_msg_count,
1240: x_msg_data,
1241: '_PUB'
1242: );

Line 1245: x_return_status := OKC_API.HANDLE_EXCEPTIONS

1241: '_PUB'
1242: );
1243:
1244: WHEN OTHERS THEN
1245: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1246: (
1247: l_api_name,
1248: G_PKG_NAME,
1249: 'OTHERS',

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

1260: x_msg_data OUT NOCOPY VARCHAR2,
1261: p_cnlv_tbl IN cnlv_tbl_type,
1262: x_cnlv_tbl OUT NOCOPY cnlv_tbl_type) IS
1263:
1264: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1265: i NUMBER := 0;
1266: BEGIN
1267: --Initialize the return status
1268: x_return_status := OKC_API.G_RET_STS_SUCCESS;

Line 1268: x_return_status := OKC_API.G_RET_STS_SUCCESS;

1264: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1265: i NUMBER := 0;
1266: BEGIN
1267: --Initialize the return status
1268: x_return_status := OKC_API.G_RET_STS_SUCCESS;
1269:
1270: IF p_cnlv_tbl.COUNT > 0 THEN
1271: i := p_cnlv_tbl.FIRST;
1272: LOOP

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

1277: x_msg_count,
1278: x_msg_data,
1279: p_cnlv_tbl(i),
1280: x_cnlv_tbl(i));
1281: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1282: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1283: x_return_status := l_return_status;
1284: raise G_EXCEPTION_HALT_VALIDATION;
1285: ELSE

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

1278: x_msg_data,
1279: p_cnlv_tbl(i),
1280: x_cnlv_tbl(i));
1281: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1282: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1283: x_return_status := l_return_status;
1284: raise G_EXCEPTION_HALT_VALIDATION;
1285: ELSE
1286: x_return_status := l_return_status;

Line 1298: OKC_API.set_message(p_app_name => g_app_name,

1294: WHEN G_EXCEPTION_HALT_VALIDATION THEN
1295: NULL;
1296:
1297: WHEN OTHERS THEN
1298: OKC_API.set_message(p_app_name => g_app_name,
1299: p_msg_name => g_unexpected_error,
1300: p_token1 => g_sqlcode_token,
1301: p_token1_value => sqlcode,
1302: p_token2 => g_sqlerrm_token,

Line 1304: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

1300: p_token1 => g_sqlcode_token,
1301: p_token1_value => sqlcode,
1302: p_token2 => g_sqlerrm_token,
1303: p_token2_value => sqlerrm);
1304: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
1305: END create_cond_lines;
1306:
1307: PROCEDURE lock_cond_lines(p_api_version IN NUMBER,
1308: p_init_msg_list IN VARCHAR2 ,

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

1311: x_msg_data OUT NOCOPY VARCHAR2,
1312: p_cnlv_rec IN cnlv_rec_type) IS
1313: l_api_name CONSTANT VARCHAR2(30) := 'lock_cond_lines';
1314: l_api_version CONSTANT NUMBER := 1.0;
1315: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1316: l_cnlv_rec cnlv_rec_type := p_cnlv_rec;
1317: BEGIN
1318: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
1319: g_pkg_name,

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

1314: l_api_version CONSTANT NUMBER := 1.0;
1315: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1316: l_cnlv_rec cnlv_rec_type := p_cnlv_rec;
1317: BEGIN
1318: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
1319: g_pkg_name,
1320: p_init_msg_list,
1321: l_api_version,
1322: p_api_version,

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

1322: p_api_version,
1323: '_PUB',
1324: x_return_status);
1325:
1326: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1327: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1328: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1329: RAISE OKC_API.G_EXCEPTION_ERROR;
1330: END IF;

Line 1327: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1323: '_PUB',
1324: x_return_status);
1325:
1326: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1327: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1328: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1329: RAISE OKC_API.G_EXCEPTION_ERROR;
1330: END IF;
1331:

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

1324: x_return_status);
1325:
1326: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1327: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1328: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1329: RAISE OKC_API.G_EXCEPTION_ERROR;
1330: END IF;
1331:
1332: -- Call to procedure of complex API

Line 1329: RAISE OKC_API.G_EXCEPTION_ERROR;

1325:
1326: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1327: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1328: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1329: RAISE OKC_API.G_EXCEPTION_ERROR;
1330: END IF;
1331:
1332: -- Call to procedure of complex API
1333: okc_conditions_pvt.lock_cond_lines(p_api_version => p_api_version,

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

1336: x_msg_count => x_msg_count,
1337: x_msg_data => x_msg_data,
1338: p_cnlv_rec => l_cnlv_rec);
1339:
1340: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1341: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1342: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1343: RAISE OKC_API.G_EXCEPTION_ERROR;
1344: END IF;

Line 1341: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1337: x_msg_data => x_msg_data,
1338: p_cnlv_rec => l_cnlv_rec);
1339:
1340: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1341: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1342: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1343: RAISE OKC_API.G_EXCEPTION_ERROR;
1344: END IF;
1345:

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

1338: p_cnlv_rec => l_cnlv_rec);
1339:
1340: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1341: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1342: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1343: RAISE OKC_API.G_EXCEPTION_ERROR;
1344: END IF;
1345:
1346: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

Line 1343: RAISE OKC_API.G_EXCEPTION_ERROR;

1339:
1340: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1341: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1342: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1343: RAISE OKC_API.G_EXCEPTION_ERROR;
1344: END IF;
1345:
1346: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1347:

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

1342: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1343: RAISE OKC_API.G_EXCEPTION_ERROR;
1344: END IF;
1345:
1346: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1347:
1348: EXCEPTION
1349: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1350: x_return_status := OKC_API.HANDLE_EXCEPTIONS

Line 1349: WHEN OKC_API.G_EXCEPTION_ERROR THEN

1345:
1346: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1347:
1348: EXCEPTION
1349: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1350: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1351: (
1352: l_api_name,
1353: G_PKG_NAME,

Line 1350: x_return_status := OKC_API.HANDLE_EXCEPTIONS

1346: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1347:
1348: EXCEPTION
1349: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1350: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1351: (
1352: l_api_name,
1353: G_PKG_NAME,
1354: 'OKC_API.G_RET_STS_ERROR',

Line 1354: 'OKC_API.G_RET_STS_ERROR',

1350: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1351: (
1352: l_api_name,
1353: G_PKG_NAME,
1354: 'OKC_API.G_RET_STS_ERROR',
1355: x_msg_count,
1356: x_msg_data,
1357: '_PUB'
1358: );

Line 1360: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

1356: x_msg_data,
1357: '_PUB'
1358: );
1359:
1360: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1361: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1362: (
1363: l_api_name,
1364: G_PKG_NAME,

Line 1361: x_return_status := OKC_API.HANDLE_EXCEPTIONS

1357: '_PUB'
1358: );
1359:
1360: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1361: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1362: (
1363: l_api_name,
1364: G_PKG_NAME,
1365: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 1365: 'OKC_API.G_RET_STS_UNEXP_ERROR',

1361: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1362: (
1363: l_api_name,
1364: G_PKG_NAME,
1365: 'OKC_API.G_RET_STS_UNEXP_ERROR',
1366: x_msg_count,
1367: x_msg_data,
1368: '_PUB'
1369: );

Line 1372: x_return_status := OKC_API.HANDLE_EXCEPTIONS

1368: '_PUB'
1369: );
1370:
1371: WHEN OTHERS THEN
1372: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1373: (
1374: l_api_name,
1375: G_PKG_NAME,
1376: 'OTHERS',

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

1385: x_return_status OUT NOCOPY VARCHAR2,
1386: x_msg_count OUT NOCOPY NUMBER,
1387: x_msg_data OUT NOCOPY VARCHAR2,
1388: p_cnlv_tbl IN cnlv_tbl_type) IS
1389: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1390: i NUMBER := 0;
1391: BEGIN
1392: x_return_status := OKC_API.G_RET_STS_SUCCESS;
1393: IF p_cnlv_tbl.COUNT > 0 THEN

Line 1392: x_return_status := OKC_API.G_RET_STS_SUCCESS;

1388: p_cnlv_tbl IN cnlv_tbl_type) IS
1389: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1390: i NUMBER := 0;
1391: BEGIN
1392: x_return_status := OKC_API.G_RET_STS_SUCCESS;
1393: IF p_cnlv_tbl.COUNT > 0 THEN
1394: i := p_cnlv_tbl.FIRST;
1395: LOOP
1396: lock_cond_lines(

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

1399: l_return_status,
1400: x_msg_count,
1401: x_msg_data,
1402: p_cnlv_tbl(i));
1403: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1404: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1405: x_return_status := l_return_status;
1406: raise G_EXCEPTION_HALT_VALIDATION;
1407: ELSE

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

1400: x_msg_count,
1401: x_msg_data,
1402: p_cnlv_tbl(i));
1403: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1404: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1405: x_return_status := l_return_status;
1406: raise G_EXCEPTION_HALT_VALIDATION;
1407: ELSE
1408: x_return_status := l_return_status;

Line 1420: OKC_API.set_message(p_app_name => g_app_name,

1416: WHEN G_EXCEPTION_HALT_VALIDATION THEN
1417: NULL;
1418:
1419: WHEN OTHERS THEN
1420: OKC_API.set_message(p_app_name => g_app_name,
1421: p_msg_name => g_unexpected_error,
1422: p_token1 => g_sqlcode_token,
1423: p_token1_value => sqlcode,
1424: p_token2 => g_sqlerrm_token,

Line 1426: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

1422: p_token1 => g_sqlcode_token,
1423: p_token1_value => sqlcode,
1424: p_token2 => g_sqlerrm_token,
1425: p_token2_value => sqlerrm);
1426: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
1427: End lock_cond_lines;
1428:
1429: PROCEDURE update_cond_lines(p_api_version IN NUMBER,
1430: p_init_msg_list IN VARCHAR2 ,

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

1435: x_cnlv_rec OUT NOCOPY cnlv_rec_type) IS
1436:
1437: l_api_name CONSTANT VARCHAR2(30) := 'update_cond_lines';
1438: l_api_version CONSTANT NUMBER := 1.0;
1439: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1440: l_cnlv_rec cnlv_rec_type := p_cnlv_rec;
1441: BEGIN
1442: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
1443: g_pkg_name,

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

1438: l_api_version CONSTANT NUMBER := 1.0;
1439: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1440: l_cnlv_rec cnlv_rec_type := p_cnlv_rec;
1441: BEGIN
1442: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
1443: g_pkg_name,
1444: p_init_msg_list,
1445: l_api_version,
1446: p_api_version,

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

1445: l_api_version,
1446: p_api_version,
1447: '_PUB',
1448: x_return_status);
1449: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1450: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1451: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1452: RAISE OKC_API.G_EXCEPTION_ERROR;
1453: END IF;

Line 1450: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1446: p_api_version,
1447: '_PUB',
1448: x_return_status);
1449: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1450: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1451: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1452: RAISE OKC_API.G_EXCEPTION_ERROR;
1453: END IF;
1454:

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

1447: '_PUB',
1448: x_return_status);
1449: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1450: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1451: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1452: RAISE OKC_API.G_EXCEPTION_ERROR;
1453: END IF;
1454:
1455: -- USER HOOK CALL FOR BEFORE, STARTS

Line 1452: RAISE OKC_API.G_EXCEPTION_ERROR;

1448: x_return_status);
1449: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1450: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1451: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1452: RAISE OKC_API.G_EXCEPTION_ERROR;
1453: END IF;
1454:
1455: -- USER HOOK CALL FOR BEFORE, STARTS
1456: g_cnlv_rec := l_cnlv_rec;

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

1458: okc_util.call_user_hook(x_return_status => x_return_status,
1459: p_package_name => g_pkg_name,
1460: p_procedure_name => l_api_name,
1461: p_before_after => 'B');
1462: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1463: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1464: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1465: RAISE OKC_API.G_EXCEPTION_ERROR;
1466: END IF;

Line 1463: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1459: p_package_name => g_pkg_name,
1460: p_procedure_name => l_api_name,
1461: p_before_after => 'B');
1462: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1463: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1464: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1465: RAISE OKC_API.G_EXCEPTION_ERROR;
1466: END IF;
1467:

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

1460: p_procedure_name => l_api_name,
1461: p_before_after => 'B');
1462: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1463: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1464: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1465: RAISE OKC_API.G_EXCEPTION_ERROR;
1466: END IF;
1467:
1468: --get values back from hook call

Line 1465: RAISE OKC_API.G_EXCEPTION_ERROR;

1461: p_before_after => 'B');
1462: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1463: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1464: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1465: RAISE OKC_API.G_EXCEPTION_ERROR;
1466: END IF;
1467:
1468: --get values back from hook call
1469: l_cnlv_rec := migrate_cnlv(l_cnlv_rec, g_cnlv_rec);

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

1476: x_msg_data => x_msg_data,
1477: p_cnlv_rec => l_cnlv_rec,
1478: x_cnlv_rec => x_cnlv_rec);
1479:
1480: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1481: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1482: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1483: RAISE OKC_API.G_EXCEPTION_ERROR;
1484: END IF;

Line 1481: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1477: p_cnlv_rec => l_cnlv_rec,
1478: x_cnlv_rec => x_cnlv_rec);
1479:
1480: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1481: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1482: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1483: RAISE OKC_API.G_EXCEPTION_ERROR;
1484: END IF;
1485:

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

1478: x_cnlv_rec => x_cnlv_rec);
1479:
1480: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1481: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1482: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1483: RAISE OKC_API.G_EXCEPTION_ERROR;
1484: END IF;
1485:
1486: --USER HOOK CALL FOR AFTER, STARTS

Line 1483: RAISE OKC_API.G_EXCEPTION_ERROR;

1479:
1480: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1481: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1482: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1483: RAISE OKC_API.G_EXCEPTION_ERROR;
1484: END IF;
1485:
1486: --USER HOOK CALL FOR AFTER, STARTS
1487: g_cnlv_rec := x_cnlv_rec;

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

1489: okc_util.call_user_hook(x_return_status => x_return_status,
1490: p_package_name => g_pkg_name,
1491: p_procedure_name => l_api_name,
1492: p_before_after => 'A');
1493: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1494: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1495: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1496: RAISE OKC_API.G_EXCEPTION_ERROR;
1497: END IF;

Line 1494: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1490: p_package_name => g_pkg_name,
1491: p_procedure_name => l_api_name,
1492: p_before_after => 'A');
1493: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1494: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1495: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1496: RAISE OKC_API.G_EXCEPTION_ERROR;
1497: END IF;
1498: --USER HOOK CALL FOR AFTER, ENDS

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

1491: p_procedure_name => l_api_name,
1492: p_before_after => 'A');
1493: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1494: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1495: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1496: RAISE OKC_API.G_EXCEPTION_ERROR;
1497: END IF;
1498: --USER HOOK CALL FOR AFTER, ENDS
1499:

Line 1496: RAISE OKC_API.G_EXCEPTION_ERROR;

1492: p_before_after => 'A');
1493: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1494: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1495: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1496: RAISE OKC_API.G_EXCEPTION_ERROR;
1497: END IF;
1498: --USER HOOK CALL FOR AFTER, ENDS
1499:
1500: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

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

1496: RAISE OKC_API.G_EXCEPTION_ERROR;
1497: END IF;
1498: --USER HOOK CALL FOR AFTER, ENDS
1499:
1500: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1501:
1502: EXCEPTION
1503: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1504: x_return_status := OKC_API.HANDLE_EXCEPTIONS

Line 1503: WHEN OKC_API.G_EXCEPTION_ERROR THEN

1499:
1500: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1501:
1502: EXCEPTION
1503: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1504: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1505: (
1506: l_api_name,
1507: G_PKG_NAME,

Line 1504: x_return_status := OKC_API.HANDLE_EXCEPTIONS

1500: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1501:
1502: EXCEPTION
1503: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1504: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1505: (
1506: l_api_name,
1507: G_PKG_NAME,
1508: 'OKC_API.G_RET_STS_ERROR',

Line 1508: 'OKC_API.G_RET_STS_ERROR',

1504: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1505: (
1506: l_api_name,
1507: G_PKG_NAME,
1508: 'OKC_API.G_RET_STS_ERROR',
1509: x_msg_count,
1510: x_msg_data,
1511: '_PUB'
1512: );

Line 1514: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

1510: x_msg_data,
1511: '_PUB'
1512: );
1513:
1514: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1515: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1516: (
1517: l_api_name,
1518: G_PKG_NAME,

Line 1515: x_return_status := OKC_API.HANDLE_EXCEPTIONS

1511: '_PUB'
1512: );
1513:
1514: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1515: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1516: (
1517: l_api_name,
1518: G_PKG_NAME,
1519: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 1519: 'OKC_API.G_RET_STS_UNEXP_ERROR',

1515: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1516: (
1517: l_api_name,
1518: G_PKG_NAME,
1519: 'OKC_API.G_RET_STS_UNEXP_ERROR',
1520: x_msg_count,
1521: x_msg_data,
1522: '_PUB'
1523: );

Line 1526: x_return_status := OKC_API.HANDLE_EXCEPTIONS

1522: '_PUB'
1523: );
1524:
1525: WHEN OTHERS THEN
1526: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1527: (
1528: l_api_name,
1529: G_PKG_NAME,
1530: 'OTHERS',

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

1541: x_msg_data OUT NOCOPY VARCHAR2,
1542: p_cnlv_tbl IN cnlv_tbl_type,
1543: x_cnlv_tbl OUT NOCOPY cnlv_tbl_type) IS
1544:
1545: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1546: i NUMBER := 0;
1547: BEGIN
1548: --Initialize the return status
1549: x_return_status := OKC_API.G_RET_STS_SUCCESS;

Line 1549: x_return_status := OKC_API.G_RET_STS_SUCCESS;

1545: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1546: i NUMBER := 0;
1547: BEGIN
1548: --Initialize the return status
1549: x_return_status := OKC_API.G_RET_STS_SUCCESS;
1550:
1551: IF p_cnlv_tbl.COUNT > 0 THEN
1552: i := p_cnlv_tbl.FIRST;
1553: LOOP

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

1558: x_msg_count,
1559: x_msg_data,
1560: p_cnlv_tbl(i),
1561: x_cnlv_tbl(i));
1562: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1563: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1564: x_return_status := l_return_status;
1565: raise G_EXCEPTION_HALT_VALIDATION;
1566: ELSE

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

1559: x_msg_data,
1560: p_cnlv_tbl(i),
1561: x_cnlv_tbl(i));
1562: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1563: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1564: x_return_status := l_return_status;
1565: raise G_EXCEPTION_HALT_VALIDATION;
1566: ELSE
1567: x_return_status := l_return_status;

Line 1579: OKC_API.set_message(p_app_name => g_app_name,

1575: WHEN G_EXCEPTION_HALT_VALIDATION THEN
1576: NULL;
1577:
1578: WHEN OTHERS THEN
1579: OKC_API.set_message(p_app_name => g_app_name,
1580: p_msg_name => g_unexpected_error,
1581: p_token1 => g_sqlcode_token,
1582: p_token1_value => sqlcode,
1583: p_token2 => g_sqlerrm_token,

Line 1585: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

1581: p_token1 => g_sqlcode_token,
1582: p_token1_value => sqlcode,
1583: p_token2 => g_sqlerrm_token,
1584: p_token2_value => sqlerrm);
1585: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
1586: END update_cond_lines;
1587:
1588: PROCEDURE delete_cond_lines(p_api_version IN NUMBER,
1589: p_init_msg_list IN VARCHAR2 ,

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

1593: p_cnlv_rec IN cnlv_rec_type) IS
1594:
1595: l_api_name CONSTANT VARCHAR2(30) := 'delete_cond_lines';
1596: l_api_version CONSTANT NUMBER := 1.0;
1597: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1598: l_cnlv_rec cnlv_rec_type := p_cnlv_rec;
1599: BEGIN
1600: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
1601: g_pkg_name,

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

1596: l_api_version CONSTANT NUMBER := 1.0;
1597: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1598: l_cnlv_rec cnlv_rec_type := p_cnlv_rec;
1599: BEGIN
1600: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
1601: g_pkg_name,
1602: p_init_msg_list,
1603: l_api_version,
1604: p_api_version,

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

1604: p_api_version,
1605: '_PUB',
1606: x_return_status);
1607:
1608: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1609: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1610: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1611: RAISE OKC_API.G_EXCEPTION_ERROR;
1612: END IF;

Line 1609: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1605: '_PUB',
1606: x_return_status);
1607:
1608: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1609: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1610: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1611: RAISE OKC_API.G_EXCEPTION_ERROR;
1612: END IF;
1613:

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

1606: x_return_status);
1607:
1608: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1609: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1610: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1611: RAISE OKC_API.G_EXCEPTION_ERROR;
1612: END IF;
1613:
1614: -- USER HOOK CALL FOR BEFORE, STARTS

Line 1611: RAISE OKC_API.G_EXCEPTION_ERROR;

1607:
1608: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1609: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1610: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1611: RAISE OKC_API.G_EXCEPTION_ERROR;
1612: END IF;
1613:
1614: -- USER HOOK CALL FOR BEFORE, STARTS
1615: g_cnlv_rec := l_cnlv_rec;

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

1617: okc_util.call_user_hook(x_return_status => x_return_status,
1618: p_package_name => g_pkg_name,
1619: p_procedure_name => l_api_name,
1620: p_before_after => 'B');
1621: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1622: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1623: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1624: RAISE OKC_API.G_EXCEPTION_ERROR;
1625: END IF;

Line 1622: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1618: p_package_name => g_pkg_name,
1619: p_procedure_name => l_api_name,
1620: p_before_after => 'B');
1621: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1622: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1623: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1624: RAISE OKC_API.G_EXCEPTION_ERROR;
1625: END IF;
1626:

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

1619: p_procedure_name => l_api_name,
1620: p_before_after => 'B');
1621: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1622: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1623: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1624: RAISE OKC_API.G_EXCEPTION_ERROR;
1625: END IF;
1626:
1627: --get values back from hook call

Line 1624: RAISE OKC_API.G_EXCEPTION_ERROR;

1620: p_before_after => 'B');
1621: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1622: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1623: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1624: RAISE OKC_API.G_EXCEPTION_ERROR;
1625: END IF;
1626:
1627: --get values back from hook call
1628: l_cnlv_rec := migrate_cnlv(l_cnlv_rec, g_cnlv_rec);

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

1633: x_return_status => x_return_status,
1634: x_msg_count => x_msg_count,
1635: x_msg_data => x_msg_data,
1636: p_cnlv_rec => l_cnlv_rec);
1637: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1638: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1639: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1640: RAISE OKC_API.G_EXCEPTION_ERROR;
1641: END IF;

Line 1638: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1634: x_msg_count => x_msg_count,
1635: x_msg_data => x_msg_data,
1636: p_cnlv_rec => l_cnlv_rec);
1637: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1638: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1639: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1640: RAISE OKC_API.G_EXCEPTION_ERROR;
1641: END IF;
1642:

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

1635: x_msg_data => x_msg_data,
1636: p_cnlv_rec => l_cnlv_rec);
1637: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1638: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1639: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1640: RAISE OKC_API.G_EXCEPTION_ERROR;
1641: END IF;
1642:
1643: --USER HOOK CALL FOR AFTER, STARTS

Line 1640: RAISE OKC_API.G_EXCEPTION_ERROR;

1636: p_cnlv_rec => l_cnlv_rec);
1637: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1638: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1639: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1640: RAISE OKC_API.G_EXCEPTION_ERROR;
1641: END IF;
1642:
1643: --USER HOOK CALL FOR AFTER, STARTS
1644: okc_util.call_user_hook(x_return_status => x_return_status,

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

1645: p_package_name => g_pkg_name,
1646: p_procedure_name => l_api_name,
1647: p_before_after => 'A');
1648:
1649: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1650: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1651: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1652: RAISE OKC_API.G_EXCEPTION_ERROR;
1653: END IF;

Line 1650: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1646: p_procedure_name => l_api_name,
1647: p_before_after => 'A');
1648:
1649: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1650: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1651: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1652: RAISE OKC_API.G_EXCEPTION_ERROR;
1653: END IF;
1654: --USER HOOK CALL FOR AFTER, ENDS

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

1647: p_before_after => 'A');
1648:
1649: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1650: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1651: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1652: RAISE OKC_API.G_EXCEPTION_ERROR;
1653: END IF;
1654: --USER HOOK CALL FOR AFTER, ENDS
1655:

Line 1652: RAISE OKC_API.G_EXCEPTION_ERROR;

1648:
1649: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1650: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1651: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1652: RAISE OKC_API.G_EXCEPTION_ERROR;
1653: END IF;
1654: --USER HOOK CALL FOR AFTER, ENDS
1655:
1656: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

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

1652: RAISE OKC_API.G_EXCEPTION_ERROR;
1653: END IF;
1654: --USER HOOK CALL FOR AFTER, ENDS
1655:
1656: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1657: EXCEPTION
1658: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1659: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1660: (

Line 1658: WHEN OKC_API.G_EXCEPTION_ERROR THEN

1654: --USER HOOK CALL FOR AFTER, ENDS
1655:
1656: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1657: EXCEPTION
1658: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1659: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1660: (
1661: l_api_name,
1662: G_PKG_NAME,

Line 1659: x_return_status := OKC_API.HANDLE_EXCEPTIONS

1655:
1656: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1657: EXCEPTION
1658: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1659: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1660: (
1661: l_api_name,
1662: G_PKG_NAME,
1663: 'OKC_API.G_RET_STS_ERROR',

Line 1663: 'OKC_API.G_RET_STS_ERROR',

1659: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1660: (
1661: l_api_name,
1662: G_PKG_NAME,
1663: 'OKC_API.G_RET_STS_ERROR',
1664: x_msg_count,
1665: x_msg_data,
1666: '_PUB'
1667: );

Line 1669: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

1665: x_msg_data,
1666: '_PUB'
1667: );
1668:
1669: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1670: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1671: (
1672: l_api_name,
1673: G_PKG_NAME,

Line 1670: x_return_status := OKC_API.HANDLE_EXCEPTIONS

1666: '_PUB'
1667: );
1668:
1669: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1670: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1671: (
1672: l_api_name,
1673: G_PKG_NAME,
1674: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 1674: 'OKC_API.G_RET_STS_UNEXP_ERROR',

1670: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1671: (
1672: l_api_name,
1673: G_PKG_NAME,
1674: 'OKC_API.G_RET_STS_UNEXP_ERROR',
1675: x_msg_count,
1676: x_msg_data,
1677: '_PUB'
1678: );

Line 1681: x_return_status := OKC_API.HANDLE_EXCEPTIONS

1677: '_PUB'
1678: );
1679:
1680: WHEN OTHERS THEN
1681: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1682: (
1683: l_api_name,
1684: G_PKG_NAME,
1685: 'OTHERS',

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

1695: x_msg_count OUT NOCOPY NUMBER,
1696: x_msg_data OUT NOCOPY VARCHAR2,
1697: p_cnlv_tbl IN cnlv_tbl_type) IS
1698:
1699: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1700: i NUMBER := 0;
1701: BEGIN
1702: --Initialize the return status
1703: x_return_status := OKC_API.G_RET_STS_SUCCESS;

Line 1703: x_return_status := OKC_API.G_RET_STS_SUCCESS;

1699: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1700: i NUMBER := 0;
1701: BEGIN
1702: --Initialize the return status
1703: x_return_status := OKC_API.G_RET_STS_SUCCESS;
1704:
1705: IF p_cnlv_tbl.COUNT > 0 THEN
1706: i := p_cnlv_tbl.FIRST;
1707: LOOP

Line 1715: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN

1711: x_return_status,
1712: x_msg_count,
1713: x_msg_data,
1714: p_cnlv_tbl(i));
1715: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1716: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN -- need to leave
1717: l_return_status := x_return_status;
1718: RAISE G_EXCEPTION_HALT_VALIDATION;
1719: ELSE

Line 1716: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN -- need to leave

1712: x_msg_count,
1713: x_msg_data,
1714: p_cnlv_tbl(i));
1715: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1716: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN -- need to leave
1717: l_return_status := x_return_status;
1718: RAISE G_EXCEPTION_HALT_VALIDATION;
1719: ELSE
1720: l_return_status := x_return_status; -- record that there was an error

Line 1732: OKC_API.set_message(p_app_name => g_app_name,

1728: WHEN G_EXCEPTION_HALT_VALIDATION THEN
1729: NULL;
1730:
1731: WHEN OTHERS THEN
1732: OKC_API.set_message(p_app_name => g_app_name,
1733: p_msg_name => g_unexpected_error,
1734: p_token1 => g_sqlcode_token,
1735: p_token1_value => sqlcode,
1736: p_token2 => g_sqlerrm_token,

Line 1738: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

1734: p_token1 => g_sqlcode_token,
1735: p_token1_value => sqlcode,
1736: p_token2 => g_sqlerrm_token,
1737: p_token2_value => sqlerrm);
1738: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
1739: END delete_cond_lines;
1740:
1741: PROCEDURE validate_cond_lines(p_api_version IN NUMBER,
1742: p_init_msg_list IN VARCHAR2 ,

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

1746: p_cnlv_rec IN cnlv_rec_type) IS
1747:
1748: l_api_name CONSTANT VARCHAR2(30) := 'validate_cond_lines';
1749: l_api_version CONSTANT NUMBER := 1.0;
1750: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1751: l_cnlv_rec cnlv_rec_type := p_cnlv_rec;
1752: BEGIN
1753: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
1754: g_pkg_name,

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

1749: l_api_version CONSTANT NUMBER := 1.0;
1750: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1751: l_cnlv_rec cnlv_rec_type := p_cnlv_rec;
1752: BEGIN
1753: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
1754: g_pkg_name,
1755: p_init_msg_list,
1756: l_api_version,
1757: p_api_version,

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

1757: p_api_version,
1758: '_PUB',
1759: x_return_status);
1760:
1761: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1762: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1763: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1764: RAISE OKC_API.G_EXCEPTION_ERROR;
1765: END IF;

Line 1762: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1758: '_PUB',
1759: x_return_status);
1760:
1761: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1762: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1763: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1764: RAISE OKC_API.G_EXCEPTION_ERROR;
1765: END IF;
1766:

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

1759: x_return_status);
1760:
1761: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1762: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1763: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1764: RAISE OKC_API.G_EXCEPTION_ERROR;
1765: END IF;
1766:
1767: -- USER HOOK CALL FOR BEFORE, STARTS

Line 1764: RAISE OKC_API.G_EXCEPTION_ERROR;

1760:
1761: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1762: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1763: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1764: RAISE OKC_API.G_EXCEPTION_ERROR;
1765: END IF;
1766:
1767: -- USER HOOK CALL FOR BEFORE, STARTS
1768: g_cnlv_rec := l_cnlv_rec;

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

1770: okc_util.call_user_hook(x_return_status => x_return_status,
1771: p_package_name => g_pkg_name,
1772: p_procedure_name => l_api_name,
1773: p_before_after => 'B');
1774: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1775: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1776: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1777: RAISE OKC_API.G_EXCEPTION_ERROR;
1778: END IF;

Line 1775: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1771: p_package_name => g_pkg_name,
1772: p_procedure_name => l_api_name,
1773: p_before_after => 'B');
1774: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1775: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1776: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1777: RAISE OKC_API.G_EXCEPTION_ERROR;
1778: END IF;
1779:

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

1772: p_procedure_name => l_api_name,
1773: p_before_after => 'B');
1774: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1775: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1776: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1777: RAISE OKC_API.G_EXCEPTION_ERROR;
1778: END IF;
1779:
1780: --get values back from hook call

Line 1777: RAISE OKC_API.G_EXCEPTION_ERROR;

1773: p_before_after => 'B');
1774: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1775: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1776: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1777: RAISE OKC_API.G_EXCEPTION_ERROR;
1778: END IF;
1779:
1780: --get values back from hook call
1781: l_cnlv_rec := migrate_cnlv(l_cnlv_rec, g_cnlv_rec);

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

1787: x_msg_count => x_msg_count,
1788: x_msg_data => x_msg_data,
1789: p_cnlv_rec => l_cnlv_rec);
1790:
1791: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1792: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1793: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1794: RAISE OKC_API.G_EXCEPTION_ERROR;
1795: END IF;

Line 1792: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1788: x_msg_data => x_msg_data,
1789: p_cnlv_rec => l_cnlv_rec);
1790:
1791: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1792: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1793: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1794: RAISE OKC_API.G_EXCEPTION_ERROR;
1795: END IF;
1796:

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

1789: p_cnlv_rec => l_cnlv_rec);
1790:
1791: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1792: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1793: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1794: RAISE OKC_API.G_EXCEPTION_ERROR;
1795: END IF;
1796:
1797: --USER HOOK CALL FOR AFTER, STARTS

Line 1794: RAISE OKC_API.G_EXCEPTION_ERROR;

1790:
1791: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1792: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1793: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1794: RAISE OKC_API.G_EXCEPTION_ERROR;
1795: END IF;
1796:
1797: --USER HOOK CALL FOR AFTER, STARTS
1798: okc_util.call_user_hook(x_return_status => x_return_status,

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

1798: okc_util.call_user_hook(x_return_status => x_return_status,
1799: p_package_name => g_pkg_name,
1800: p_procedure_name => l_api_name,
1801: p_before_after => 'A');
1802: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1803: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1804: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1805: RAISE OKC_API.G_EXCEPTION_ERROR;
1806: END IF;

Line 1803: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1799: p_package_name => g_pkg_name,
1800: p_procedure_name => l_api_name,
1801: p_before_after => 'A');
1802: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1803: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1804: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1805: RAISE OKC_API.G_EXCEPTION_ERROR;
1806: END IF;
1807: --USER HOOK CALL FOR AFTER, ENDS

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

1800: p_procedure_name => l_api_name,
1801: p_before_after => 'A');
1802: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1803: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1804: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1805: RAISE OKC_API.G_EXCEPTION_ERROR;
1806: END IF;
1807: --USER HOOK CALL FOR AFTER, ENDS
1808:

Line 1805: RAISE OKC_API.G_EXCEPTION_ERROR;

1801: p_before_after => 'A');
1802: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1803: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1804: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1805: RAISE OKC_API.G_EXCEPTION_ERROR;
1806: END IF;
1807: --USER HOOK CALL FOR AFTER, ENDS
1808:
1809: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

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

1805: RAISE OKC_API.G_EXCEPTION_ERROR;
1806: END IF;
1807: --USER HOOK CALL FOR AFTER, ENDS
1808:
1809: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1810:
1811: EXCEPTION
1812: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1813: x_return_status := OKC_API.HANDLE_EXCEPTIONS

Line 1812: WHEN OKC_API.G_EXCEPTION_ERROR THEN

1808:
1809: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1810:
1811: EXCEPTION
1812: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1813: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1814: (
1815: l_api_name,
1816: G_PKG_NAME,

Line 1813: x_return_status := OKC_API.HANDLE_EXCEPTIONS

1809: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1810:
1811: EXCEPTION
1812: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1813: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1814: (
1815: l_api_name,
1816: G_PKG_NAME,
1817: 'OKC_API.G_RET_STS_ERROR',

Line 1817: 'OKC_API.G_RET_STS_ERROR',

1813: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1814: (
1815: l_api_name,
1816: G_PKG_NAME,
1817: 'OKC_API.G_RET_STS_ERROR',
1818: x_msg_count,
1819: x_msg_data,
1820: '_PUB'
1821: );

Line 1823: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

1819: x_msg_data,
1820: '_PUB'
1821: );
1822:
1823: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1824: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1825: (
1826: l_api_name,
1827: G_PKG_NAME,

Line 1824: x_return_status := OKC_API.HANDLE_EXCEPTIONS

1820: '_PUB'
1821: );
1822:
1823: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1824: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1825: (
1826: l_api_name,
1827: G_PKG_NAME,
1828: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 1828: 'OKC_API.G_RET_STS_UNEXP_ERROR',

1824: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1825: (
1826: l_api_name,
1827: G_PKG_NAME,
1828: 'OKC_API.G_RET_STS_UNEXP_ERROR',
1829: x_msg_count,
1830: x_msg_data,
1831: '_PUB'
1832: );

Line 1835: x_return_status := OKC_API.HANDLE_EXCEPTIONS

1831: '_PUB'
1832: );
1833:
1834: WHEN OTHERS THEN
1835: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1836: (
1837: l_api_name,
1838: G_PKG_NAME,
1839: 'OTHERS',

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

1849: x_msg_count OUT NOCOPY NUMBER,
1850: x_msg_data OUT NOCOPY VARCHAR2,
1851: p_cnlv_tbl IN cnlv_tbl_type) IS
1852:
1853: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1854: i NUMBER := 0;
1855: BEGIN
1856: --Initialize the return status
1857: x_return_status := OKC_API.G_RET_STS_SUCCESS;

Line 1857: x_return_status := OKC_API.G_RET_STS_SUCCESS;

1853: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1854: i NUMBER := 0;
1855: BEGIN
1856: --Initialize the return status
1857: x_return_status := OKC_API.G_RET_STS_SUCCESS;
1858:
1859: IF p_cnlv_tbl.COUNT > 0 THEN
1860: i := p_cnlv_tbl.FIRST;
1861: LOOP

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

1865: l_return_status,
1866: x_msg_count,
1867: x_msg_data,
1868: p_cnlv_tbl(i));
1869: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1870: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1871: x_return_status := l_return_status;
1872: raise G_EXCEPTION_HALT_VALIDATION;
1873: ELSE

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

1866: x_msg_count,
1867: x_msg_data,
1868: p_cnlv_tbl(i));
1869: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1870: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1871: x_return_status := l_return_status;
1872: raise G_EXCEPTION_HALT_VALIDATION;
1873: ELSE
1874: x_return_status := l_return_status;

Line 1886: OKC_API.set_message(p_app_name => g_app_name,

1882: WHEN G_EXCEPTION_HALT_VALIDATION THEN
1883: NULL;
1884:
1885: WHEN OTHERS THEN
1886: OKC_API.set_message(p_app_name => g_app_name,
1887: p_msg_name => g_unexpected_error,
1888: p_token1 => g_sqlcode_token,
1889: p_token1_value => sqlcode,
1890: p_token2 => g_sqlerrm_token,

Line 1892: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

1888: p_token1 => g_sqlcode_token,
1889: p_token1_value => sqlcode,
1890: p_token2 => g_sqlerrm_token,
1891: p_token2_value => sqlerrm);
1892: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
1893: END validate_cond_lines;
1894:
1895: --Procedures for condition occurs
1896:

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

1903: x_coev_rec OUT NOCOPY coev_rec_type) IS
1904:
1905: l_api_name CONSTANT VARCHAR2(30) := 'create_cond_occurs';
1906: l_api_version CONSTANT NUMBER := 1.0;
1907: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1908: l_coev_rec coev_rec_type := p_coev_rec;
1909: BEGIN
1910: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
1911: g_pkg_name,

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

1906: l_api_version CONSTANT NUMBER := 1.0;
1907: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1908: l_coev_rec coev_rec_type := p_coev_rec;
1909: BEGIN
1910: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
1911: g_pkg_name,
1912: p_init_msg_list,
1913: l_api_version,
1914: p_api_version,

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

1914: p_api_version,
1915: '_PUB',
1916: x_return_status);
1917:
1918: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1919: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1920: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1921: RAISE OKC_API.G_EXCEPTION_ERROR;
1922: END IF;

Line 1919: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1915: '_PUB',
1916: x_return_status);
1917:
1918: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1919: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1920: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1921: RAISE OKC_API.G_EXCEPTION_ERROR;
1922: END IF;
1923:

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

1916: x_return_status);
1917:
1918: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1919: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1920: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1921: RAISE OKC_API.G_EXCEPTION_ERROR;
1922: END IF;
1923:
1924: -- USER HOOK CALL FOR BEFORE, STARTS

Line 1921: RAISE OKC_API.G_EXCEPTION_ERROR;

1917:
1918: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1919: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1920: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1921: RAISE OKC_API.G_EXCEPTION_ERROR;
1922: END IF;
1923:
1924: -- USER HOOK CALL FOR BEFORE, STARTS
1925: g_coev_rec := l_coev_rec;

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

1928: p_package_name => g_pkg_name,
1929: p_procedure_name => l_api_name,
1930: p_before_after => 'B');
1931:
1932: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1933: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1934: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1935: RAISE OKC_API.G_EXCEPTION_ERROR;
1936: END IF;

Line 1933: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1929: p_procedure_name => l_api_name,
1930: p_before_after => 'B');
1931:
1932: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1933: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1934: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1935: RAISE OKC_API.G_EXCEPTION_ERROR;
1936: END IF;
1937:

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

1930: p_before_after => 'B');
1931:
1932: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1933: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1934: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1935: RAISE OKC_API.G_EXCEPTION_ERROR;
1936: END IF;
1937:
1938: --get values back from hook call

Line 1935: RAISE OKC_API.G_EXCEPTION_ERROR;

1931:
1932: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1933: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1934: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1935: RAISE OKC_API.G_EXCEPTION_ERROR;
1936: END IF;
1937:
1938: --get values back from hook call
1939: l_coev_rec := migrate_coev(l_coev_rec, g_coev_rec);

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

1945: x_msg_count => x_msg_count,
1946: x_msg_data => x_msg_data,
1947: p_coev_rec => l_coev_rec,
1948: x_coev_rec => x_coev_rec);
1949: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1950: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1951: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1952: RAISE OKC_API.G_EXCEPTION_ERROR;
1953: END IF;

Line 1950: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1946: x_msg_data => x_msg_data,
1947: p_coev_rec => l_coev_rec,
1948: x_coev_rec => x_coev_rec);
1949: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1950: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1951: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1952: RAISE OKC_API.G_EXCEPTION_ERROR;
1953: END IF;
1954:

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

1947: p_coev_rec => l_coev_rec,
1948: x_coev_rec => x_coev_rec);
1949: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1950: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1951: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1952: RAISE OKC_API.G_EXCEPTION_ERROR;
1953: END IF;
1954:
1955: --USER HOOK CALL FOR AFTER, STARTS

Line 1952: RAISE OKC_API.G_EXCEPTION_ERROR;

1948: x_coev_rec => x_coev_rec);
1949: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1950: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1951: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1952: RAISE OKC_API.G_EXCEPTION_ERROR;
1953: END IF;
1954:
1955: --USER HOOK CALL FOR AFTER, STARTS
1956: g_coev_rec := x_coev_rec;

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

1959: p_package_name => g_pkg_name,
1960: p_procedure_name => l_api_name,
1961: p_before_after => 'A');
1962:
1963: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1964: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1965: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1966: RAISE OKC_API.G_EXCEPTION_ERROR;
1967: END IF;

Line 1964: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1960: p_procedure_name => l_api_name,
1961: p_before_after => 'A');
1962:
1963: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1964: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1965: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1966: RAISE OKC_API.G_EXCEPTION_ERROR;
1967: END IF;
1968: --USER HOOK CALL FOR AFTER, ENDS

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

1961: p_before_after => 'A');
1962:
1963: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1964: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1965: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1966: RAISE OKC_API.G_EXCEPTION_ERROR;
1967: END IF;
1968: --USER HOOK CALL FOR AFTER, ENDS
1969:

Line 1966: RAISE OKC_API.G_EXCEPTION_ERROR;

1962:
1963: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1964: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1965: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1966: RAISE OKC_API.G_EXCEPTION_ERROR;
1967: END IF;
1968: --USER HOOK CALL FOR AFTER, ENDS
1969:
1970: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

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

1966: RAISE OKC_API.G_EXCEPTION_ERROR;
1967: END IF;
1968: --USER HOOK CALL FOR AFTER, ENDS
1969:
1970: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1971:
1972: EXCEPTION
1973: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1974: x_return_status := OKC_API.HANDLE_EXCEPTIONS

Line 1973: WHEN OKC_API.G_EXCEPTION_ERROR THEN

1969:
1970: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1971:
1972: EXCEPTION
1973: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1974: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1975: (
1976: l_api_name,
1977: G_PKG_NAME,

Line 1974: x_return_status := OKC_API.HANDLE_EXCEPTIONS

1970: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1971:
1972: EXCEPTION
1973: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1974: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1975: (
1976: l_api_name,
1977: G_PKG_NAME,
1978: 'OKC_API.G_RET_STS_ERROR',

Line 1978: 'OKC_API.G_RET_STS_ERROR',

1974: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1975: (
1976: l_api_name,
1977: G_PKG_NAME,
1978: 'OKC_API.G_RET_STS_ERROR',
1979: x_msg_count,
1980: x_msg_data,
1981: '_PUB'
1982: );

Line 1984: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

1980: x_msg_data,
1981: '_PUB'
1982: );
1983:
1984: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1985: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1986: (
1987: l_api_name,
1988: G_PKG_NAME,

Line 1985: x_return_status := OKC_API.HANDLE_EXCEPTIONS

1981: '_PUB'
1982: );
1983:
1984: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1985: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1986: (
1987: l_api_name,
1988: G_PKG_NAME,
1989: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 1989: 'OKC_API.G_RET_STS_UNEXP_ERROR',

1985: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1986: (
1987: l_api_name,
1988: G_PKG_NAME,
1989: 'OKC_API.G_RET_STS_UNEXP_ERROR',
1990: x_msg_count,
1991: x_msg_data,
1992: '_PUB'
1993: );

Line 1996: x_return_status := OKC_API.HANDLE_EXCEPTIONS

1992: '_PUB'
1993: );
1994:
1995: WHEN OTHERS THEN
1996: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1997: (
1998: l_api_name,
1999: G_PKG_NAME,
2000: 'OTHERS',

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

2011: x_msg_data OUT NOCOPY VARCHAR2,
2012: p_coev_tbl IN coev_tbl_type,
2013: x_coev_tbl OUT NOCOPY coev_tbl_type) IS
2014:
2015: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2016: i NUMBER := 0;
2017: BEGIN
2018: --Initialize the return status
2019: x_return_status := OKC_API.G_RET_STS_SUCCESS;

Line 2019: x_return_status := OKC_API.G_RET_STS_SUCCESS;

2015: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2016: i NUMBER := 0;
2017: BEGIN
2018: --Initialize the return status
2019: x_return_status := OKC_API.G_RET_STS_SUCCESS;
2020:
2021: IF p_coev_tbl.COUNT > 0 THEN
2022: i := p_coev_tbl.FIRST;
2023: LOOP

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

2028: x_msg_count,
2029: x_msg_data,
2030: p_coev_tbl(i),
2031: x_coev_tbl(i));
2032: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2033: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2034: x_return_status := l_return_status;
2035: raise G_EXCEPTION_HALT_VALIDATION;
2036: ELSE

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

2029: x_msg_data,
2030: p_coev_tbl(i),
2031: x_coev_tbl(i));
2032: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2033: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2034: x_return_status := l_return_status;
2035: raise G_EXCEPTION_HALT_VALIDATION;
2036: ELSE
2037: x_return_status := l_return_status;

Line 2049: OKC_API.set_message(p_app_name => g_app_name,

2045: WHEN G_EXCEPTION_HALT_VALIDATION THEN
2046: NULL;
2047:
2048: WHEN OTHERS THEN
2049: OKC_API.set_message(p_app_name => g_app_name,
2050: p_msg_name => g_unexpected_error,
2051: p_token1 => g_sqlcode_token,
2052: p_token1_value => sqlcode,
2053: p_token2 => g_sqlerrm_token,

Line 2055: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

2051: p_token1 => g_sqlcode_token,
2052: p_token1_value => sqlcode,
2053: p_token2 => g_sqlerrm_token,
2054: p_token2_value => sqlerrm);
2055: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
2056: END create_cond_occurs;
2057:
2058:
2059: PROCEDURE delete_cond_occurs(p_api_version IN NUMBER,

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

2064: p_coev_rec IN coev_rec_type) IS
2065:
2066: l_api_name CONSTANT VARCHAR2(30) := 'delete_cond_occurs';
2067: l_api_version CONSTANT NUMBER := 1.0;
2068: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2069: l_coev_rec coev_rec_type := p_coev_rec;
2070: BEGIN
2071: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
2072: g_pkg_name,

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

2067: l_api_version CONSTANT NUMBER := 1.0;
2068: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2069: l_coev_rec coev_rec_type := p_coev_rec;
2070: BEGIN
2071: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
2072: g_pkg_name,
2073: p_init_msg_list,
2074: l_api_version,
2075: p_api_version,

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

2075: p_api_version,
2076: '_PUB',
2077: x_return_status);
2078:
2079: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2080: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2081: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2082: RAISE OKC_API.G_EXCEPTION_ERROR;
2083: END IF;

Line 2080: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2076: '_PUB',
2077: x_return_status);
2078:
2079: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2080: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2081: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2082: RAISE OKC_API.G_EXCEPTION_ERROR;
2083: END IF;
2084:

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

2077: x_return_status);
2078:
2079: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2080: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2081: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2082: RAISE OKC_API.G_EXCEPTION_ERROR;
2083: END IF;
2084:
2085: -- USER HOOK CALL FOR BEFORE, STARTS

Line 2082: RAISE OKC_API.G_EXCEPTION_ERROR;

2078:
2079: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2080: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2081: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2082: RAISE OKC_API.G_EXCEPTION_ERROR;
2083: END IF;
2084:
2085: -- USER HOOK CALL FOR BEFORE, STARTS
2086: g_coev_rec := l_coev_rec;

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

2088: okc_util.call_user_hook(x_return_status => x_return_status,
2089: p_package_name => g_pkg_name,
2090: p_procedure_name => l_api_name,
2091: p_before_after => 'B');
2092: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2093: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2094: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2095: RAISE OKC_API.G_EXCEPTION_ERROR;
2096: END IF;

Line 2093: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2089: p_package_name => g_pkg_name,
2090: p_procedure_name => l_api_name,
2091: p_before_after => 'B');
2092: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2093: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2094: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2095: RAISE OKC_API.G_EXCEPTION_ERROR;
2096: END IF;
2097:

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

2090: p_procedure_name => l_api_name,
2091: p_before_after => 'B');
2092: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2093: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2094: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2095: RAISE OKC_API.G_EXCEPTION_ERROR;
2096: END IF;
2097:
2098: --get values back from hook call

Line 2095: RAISE OKC_API.G_EXCEPTION_ERROR;

2091: p_before_after => 'B');
2092: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2093: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2094: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2095: RAISE OKC_API.G_EXCEPTION_ERROR;
2096: END IF;
2097:
2098: --get values back from hook call
2099: l_coev_rec := migrate_coev(l_coev_rec, g_coev_rec);

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

2104: x_return_status => x_return_status,
2105: x_msg_count => x_msg_count,
2106: x_msg_data => x_msg_data,
2107: p_coev_rec => l_coev_rec);
2108: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2109: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2110: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2111: RAISE OKC_API.G_EXCEPTION_ERROR;
2112: END IF;

Line 2109: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2105: x_msg_count => x_msg_count,
2106: x_msg_data => x_msg_data,
2107: p_coev_rec => l_coev_rec);
2108: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2109: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2110: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2111: RAISE OKC_API.G_EXCEPTION_ERROR;
2112: END IF;
2113:

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

2106: x_msg_data => x_msg_data,
2107: p_coev_rec => l_coev_rec);
2108: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2109: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2110: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2111: RAISE OKC_API.G_EXCEPTION_ERROR;
2112: END IF;
2113:
2114: --USER HOOK CALL FOR AFTER, STARTS

Line 2111: RAISE OKC_API.G_EXCEPTION_ERROR;

2107: p_coev_rec => l_coev_rec);
2108: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2109: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2110: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2111: RAISE OKC_API.G_EXCEPTION_ERROR;
2112: END IF;
2113:
2114: --USER HOOK CALL FOR AFTER, STARTS
2115: okc_util.call_user_hook(x_return_status => x_return_status,

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

2116: p_package_name => g_pkg_name,
2117: p_procedure_name => l_api_name,
2118: p_before_after => 'A');
2119:
2120: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2121: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2122: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2123: RAISE OKC_API.G_EXCEPTION_ERROR;
2124: END IF;

Line 2121: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2117: p_procedure_name => l_api_name,
2118: p_before_after => 'A');
2119:
2120: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2121: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2122: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2123: RAISE OKC_API.G_EXCEPTION_ERROR;
2124: END IF;
2125: --USER HOOK CALL FOR AFTER, ENDS

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

2118: p_before_after => 'A');
2119:
2120: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2121: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2122: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2123: RAISE OKC_API.G_EXCEPTION_ERROR;
2124: END IF;
2125: --USER HOOK CALL FOR AFTER, ENDS
2126:

Line 2123: RAISE OKC_API.G_EXCEPTION_ERROR;

2119:
2120: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2121: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2122: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2123: RAISE OKC_API.G_EXCEPTION_ERROR;
2124: END IF;
2125: --USER HOOK CALL FOR AFTER, ENDS
2126:
2127: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

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

2123: RAISE OKC_API.G_EXCEPTION_ERROR;
2124: END IF;
2125: --USER HOOK CALL FOR AFTER, ENDS
2126:
2127: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
2128: EXCEPTION
2129: WHEN OKC_API.G_EXCEPTION_ERROR THEN
2130: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2131: (

Line 2129: WHEN OKC_API.G_EXCEPTION_ERROR THEN

2125: --USER HOOK CALL FOR AFTER, ENDS
2126:
2127: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
2128: EXCEPTION
2129: WHEN OKC_API.G_EXCEPTION_ERROR THEN
2130: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2131: (
2132: l_api_name,
2133: G_PKG_NAME,

Line 2130: x_return_status := OKC_API.HANDLE_EXCEPTIONS

2126:
2127: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
2128: EXCEPTION
2129: WHEN OKC_API.G_EXCEPTION_ERROR THEN
2130: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2131: (
2132: l_api_name,
2133: G_PKG_NAME,
2134: 'OKC_API.G_RET_STS_ERROR',

Line 2134: 'OKC_API.G_RET_STS_ERROR',

2130: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2131: (
2132: l_api_name,
2133: G_PKG_NAME,
2134: 'OKC_API.G_RET_STS_ERROR',
2135: x_msg_count,
2136: x_msg_data,
2137: '_PUB'
2138: );

Line 2140: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

2136: x_msg_data,
2137: '_PUB'
2138: );
2139:
2140: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
2141: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2142: (
2143: l_api_name,
2144: G_PKG_NAME,

Line 2141: x_return_status := OKC_API.HANDLE_EXCEPTIONS

2137: '_PUB'
2138: );
2139:
2140: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
2141: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2142: (
2143: l_api_name,
2144: G_PKG_NAME,
2145: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 2145: 'OKC_API.G_RET_STS_UNEXP_ERROR',

2141: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2142: (
2143: l_api_name,
2144: G_PKG_NAME,
2145: 'OKC_API.G_RET_STS_UNEXP_ERROR',
2146: x_msg_count,
2147: x_msg_data,
2148: '_PUB'
2149: );

Line 2152: x_return_status := OKC_API.HANDLE_EXCEPTIONS

2148: '_PUB'
2149: );
2150:
2151: WHEN OTHERS THEN
2152: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2153: (
2154: l_api_name,
2155: G_PKG_NAME,
2156: 'OTHERS',

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

2166: x_msg_count OUT NOCOPY NUMBER,
2167: x_msg_data OUT NOCOPY VARCHAR2,
2168: p_coev_tbl IN coev_tbl_type) IS
2169:
2170: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2171: i NUMBER := 0;
2172: BEGIN
2173: --Initialize the return status
2174: x_return_status := OKC_API.G_RET_STS_SUCCESS;

Line 2174: x_return_status := OKC_API.G_RET_STS_SUCCESS;

2170: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2171: i NUMBER := 0;
2172: BEGIN
2173: --Initialize the return status
2174: x_return_status := OKC_API.G_RET_STS_SUCCESS;
2175:
2176: IF p_coev_tbl.COUNT > 0 THEN
2177: i := p_coev_tbl.FIRST;
2178: LOOP

Line 2186: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN

2182: x_return_status,
2183: x_msg_count,
2184: x_msg_data,
2185: p_coev_tbl(i));
2186: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2187: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN -- need to leave
2188: l_return_status := x_return_status;
2189: RAISE G_EXCEPTION_HALT_VALIDATION;
2190: ELSE

Line 2187: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN -- need to leave

2183: x_msg_count,
2184: x_msg_data,
2185: p_coev_tbl(i));
2186: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2187: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN -- need to leave
2188: l_return_status := x_return_status;
2189: RAISE G_EXCEPTION_HALT_VALIDATION;
2190: ELSE
2191: l_return_status := x_return_status; -- record that there was an error

Line 2203: OKC_API.set_message(p_app_name => g_app_name,

2199: WHEN G_EXCEPTION_HALT_VALIDATION THEN
2200: NULL;
2201:
2202: WHEN OTHERS THEN
2203: OKC_API.set_message(p_app_name => g_app_name,
2204: p_msg_name => g_unexpected_error,
2205: p_token1 => g_sqlcode_token,
2206: p_token1_value => sqlcode,
2207: p_token2 => g_sqlerrm_token,

Line 2209: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

2205: p_token1 => g_sqlcode_token,
2206: p_token1_value => sqlcode,
2207: p_token2 => g_sqlerrm_token,
2208: p_token2_value => sqlerrm);
2209: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
2210: END delete_cond_occurs;
2211:
2212: PROCEDURE validate_cond_occurs(p_api_version IN NUMBER,
2213: p_init_msg_list IN VARCHAR2 ,

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

2217: p_coev_rec IN coev_rec_type) IS
2218:
2219: l_api_name CONSTANT VARCHAR2(30) := 'validate_cond_occurs';
2220: l_api_version CONSTANT NUMBER := 1.0;
2221: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2222: l_coev_rec coev_rec_type := p_coev_rec;
2223: BEGIN
2224: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
2225: g_pkg_name,

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

2220: l_api_version CONSTANT NUMBER := 1.0;
2221: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2222: l_coev_rec coev_rec_type := p_coev_rec;
2223: BEGIN
2224: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
2225: g_pkg_name,
2226: p_init_msg_list,
2227: l_api_version,
2228: p_api_version,

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

2228: p_api_version,
2229: '_PUB',
2230: x_return_status);
2231:
2232: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2233: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2234: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2235: RAISE OKC_API.G_EXCEPTION_ERROR;
2236: END IF;

Line 2233: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2229: '_PUB',
2230: x_return_status);
2231:
2232: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2233: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2234: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2235: RAISE OKC_API.G_EXCEPTION_ERROR;
2236: END IF;
2237:

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

2230: x_return_status);
2231:
2232: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2233: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2234: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2235: RAISE OKC_API.G_EXCEPTION_ERROR;
2236: END IF;
2237:
2238: -- USER HOOK CALL FOR BEFORE, STARTS

Line 2235: RAISE OKC_API.G_EXCEPTION_ERROR;

2231:
2232: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2233: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2234: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2235: RAISE OKC_API.G_EXCEPTION_ERROR;
2236: END IF;
2237:
2238: -- USER HOOK CALL FOR BEFORE, STARTS
2239: g_coev_rec := l_coev_rec;

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

2241: okc_util.call_user_hook(x_return_status => x_return_status,
2242: p_package_name => g_pkg_name,
2243: p_procedure_name => l_api_name,
2244: p_before_after => 'B');
2245: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2246: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2247: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2248: RAISE OKC_API.G_EXCEPTION_ERROR;
2249: END IF;

Line 2246: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2242: p_package_name => g_pkg_name,
2243: p_procedure_name => l_api_name,
2244: p_before_after => 'B');
2245: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2246: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2247: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2248: RAISE OKC_API.G_EXCEPTION_ERROR;
2249: END IF;
2250:

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

2243: p_procedure_name => l_api_name,
2244: p_before_after => 'B');
2245: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2246: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2247: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2248: RAISE OKC_API.G_EXCEPTION_ERROR;
2249: END IF;
2250:
2251: --get values back from hook call

Line 2248: RAISE OKC_API.G_EXCEPTION_ERROR;

2244: p_before_after => 'B');
2245: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2246: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2247: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2248: RAISE OKC_API.G_EXCEPTION_ERROR;
2249: END IF;
2250:
2251: --get values back from hook call
2252: l_coev_rec := migrate_coev(l_coev_rec, g_coev_rec);

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

2258: x_msg_count => x_msg_count,
2259: x_msg_data => x_msg_data,
2260: p_coev_rec => l_coev_rec);
2261:
2262: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2263: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2264: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2265: RAISE OKC_API.G_EXCEPTION_ERROR;
2266: END IF;

Line 2263: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2259: x_msg_data => x_msg_data,
2260: p_coev_rec => l_coev_rec);
2261:
2262: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2263: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2264: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2265: RAISE OKC_API.G_EXCEPTION_ERROR;
2266: END IF;
2267:

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

2260: p_coev_rec => l_coev_rec);
2261:
2262: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2263: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2264: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2265: RAISE OKC_API.G_EXCEPTION_ERROR;
2266: END IF;
2267:
2268: --USER HOOK CALL FOR AFTER, STARTS

Line 2265: RAISE OKC_API.G_EXCEPTION_ERROR;

2261:
2262: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2263: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2264: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2265: RAISE OKC_API.G_EXCEPTION_ERROR;
2266: END IF;
2267:
2268: --USER HOOK CALL FOR AFTER, STARTS
2269: okc_util.call_user_hook(x_return_status => x_return_status,

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

2269: okc_util.call_user_hook(x_return_status => x_return_status,
2270: p_package_name => g_pkg_name,
2271: p_procedure_name => l_api_name,
2272: p_before_after => 'A');
2273: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2274: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2275: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2276: RAISE OKC_API.G_EXCEPTION_ERROR;
2277: END IF;

Line 2274: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2270: p_package_name => g_pkg_name,
2271: p_procedure_name => l_api_name,
2272: p_before_after => 'A');
2273: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2274: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2275: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2276: RAISE OKC_API.G_EXCEPTION_ERROR;
2277: END IF;
2278: --USER HOOK CALL FOR AFTER, ENDS

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

2271: p_procedure_name => l_api_name,
2272: p_before_after => 'A');
2273: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2274: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2275: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2276: RAISE OKC_API.G_EXCEPTION_ERROR;
2277: END IF;
2278: --USER HOOK CALL FOR AFTER, ENDS
2279:

Line 2276: RAISE OKC_API.G_EXCEPTION_ERROR;

2272: p_before_after => 'A');
2273: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2274: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2275: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2276: RAISE OKC_API.G_EXCEPTION_ERROR;
2277: END IF;
2278: --USER HOOK CALL FOR AFTER, ENDS
2279:
2280: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

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

2276: RAISE OKC_API.G_EXCEPTION_ERROR;
2277: END IF;
2278: --USER HOOK CALL FOR AFTER, ENDS
2279:
2280: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
2281:
2282: EXCEPTION
2283: WHEN OKC_API.G_EXCEPTION_ERROR THEN
2284: x_return_status := OKC_API.HANDLE_EXCEPTIONS

Line 2283: WHEN OKC_API.G_EXCEPTION_ERROR THEN

2279:
2280: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
2281:
2282: EXCEPTION
2283: WHEN OKC_API.G_EXCEPTION_ERROR THEN
2284: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2285: (
2286: l_api_name,
2287: G_PKG_NAME,

Line 2284: x_return_status := OKC_API.HANDLE_EXCEPTIONS

2280: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
2281:
2282: EXCEPTION
2283: WHEN OKC_API.G_EXCEPTION_ERROR THEN
2284: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2285: (
2286: l_api_name,
2287: G_PKG_NAME,
2288: 'OKC_API.G_RET_STS_ERROR',

Line 2288: 'OKC_API.G_RET_STS_ERROR',

2284: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2285: (
2286: l_api_name,
2287: G_PKG_NAME,
2288: 'OKC_API.G_RET_STS_ERROR',
2289: x_msg_count,
2290: x_msg_data,
2291: '_PUB'
2292: );

Line 2294: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

2290: x_msg_data,
2291: '_PUB'
2292: );
2293:
2294: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
2295: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2296: (
2297: l_api_name,
2298: G_PKG_NAME,

Line 2295: x_return_status := OKC_API.HANDLE_EXCEPTIONS

2291: '_PUB'
2292: );
2293:
2294: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
2295: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2296: (
2297: l_api_name,
2298: G_PKG_NAME,
2299: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 2299: 'OKC_API.G_RET_STS_UNEXP_ERROR',

2295: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2296: (
2297: l_api_name,
2298: G_PKG_NAME,
2299: 'OKC_API.G_RET_STS_UNEXP_ERROR',
2300: x_msg_count,
2301: x_msg_data,
2302: '_PUB'
2303: );

Line 2306: x_return_status := OKC_API.HANDLE_EXCEPTIONS

2302: '_PUB'
2303: );
2304:
2305: WHEN OTHERS THEN
2306: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2307: (
2308: l_api_name,
2309: G_PKG_NAME,
2310: 'OTHERS',

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

2320: x_msg_count OUT NOCOPY NUMBER,
2321: x_msg_data OUT NOCOPY VARCHAR2,
2322: p_coev_tbl IN coev_tbl_type) IS
2323:
2324: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2325: i NUMBER := 0;
2326: BEGIN
2327: --Initialize the return status
2328: x_return_status := OKC_API.G_RET_STS_SUCCESS;

Line 2328: x_return_status := OKC_API.G_RET_STS_SUCCESS;

2324: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2325: i NUMBER := 0;
2326: BEGIN
2327: --Initialize the return status
2328: x_return_status := OKC_API.G_RET_STS_SUCCESS;
2329:
2330: IF p_coev_tbl.COUNT > 0 THEN
2331: i := p_coev_tbl.FIRST;
2332: LOOP

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

2336: l_return_status,
2337: x_msg_count,
2338: x_msg_data,
2339: p_coev_tbl(i));
2340: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2341: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2342: x_return_status := l_return_status;
2343: raise G_EXCEPTION_HALT_VALIDATION;
2344: ELSE

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

2337: x_msg_count,
2338: x_msg_data,
2339: p_coev_tbl(i));
2340: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2341: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2342: x_return_status := l_return_status;
2343: raise G_EXCEPTION_HALT_VALIDATION;
2344: ELSE
2345: x_return_status := l_return_status;

Line 2357: OKC_API.set_message(p_app_name => g_app_name,

2353: WHEN G_EXCEPTION_HALT_VALIDATION THEN
2354: NULL;
2355:
2356: WHEN OTHERS THEN
2357: OKC_API.set_message(p_app_name => g_app_name,
2358: p_msg_name => g_unexpected_error,
2359: p_token1 => g_sqlcode_token,
2360: p_token1_value => sqlcode,
2361: p_token2 => g_sqlerrm_token,

Line 2363: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

2359: p_token1 => g_sqlcode_token,
2360: p_token1_value => sqlcode,
2361: p_token2 => g_sqlerrm_token,
2362: p_token2_value => sqlerrm);
2363: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
2364: END validate_cond_occurs;
2365:
2366: --Procedures for action attribute values
2367:

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

2374: x_aavv_rec OUT NOCOPY aavv_rec_type) IS
2375:
2376: l_api_name CONSTANT VARCHAR2(30) := 'create_act_att_vals';
2377: l_api_version CONSTANT NUMBER := 1.0;
2378: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2379: l_aavv_rec aavv_rec_type := p_aavv_rec;
2380: BEGIN
2381: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
2382: g_pkg_name,

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

2377: l_api_version CONSTANT NUMBER := 1.0;
2378: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2379: l_aavv_rec aavv_rec_type := p_aavv_rec;
2380: BEGIN
2381: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
2382: g_pkg_name,
2383: p_init_msg_list,
2384: l_api_version,
2385: p_api_version,

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

2385: p_api_version,
2386: '_PUB',
2387: x_return_status);
2388:
2389: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2390: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2391: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2392: RAISE OKC_API.G_EXCEPTION_ERROR;
2393: END IF;

Line 2390: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2386: '_PUB',
2387: x_return_status);
2388:
2389: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2390: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2391: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2392: RAISE OKC_API.G_EXCEPTION_ERROR;
2393: END IF;
2394:

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

2387: x_return_status);
2388:
2389: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2390: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2391: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2392: RAISE OKC_API.G_EXCEPTION_ERROR;
2393: END IF;
2394:
2395: -- USER HOOK CALL FOR BEFORE, STARTS

Line 2392: RAISE OKC_API.G_EXCEPTION_ERROR;

2388:
2389: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2390: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2391: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2392: RAISE OKC_API.G_EXCEPTION_ERROR;
2393: END IF;
2394:
2395: -- USER HOOK CALL FOR BEFORE, STARTS
2396: g_aavv_rec := l_aavv_rec;

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

2399: p_package_name => g_pkg_name,
2400: p_procedure_name => l_api_name,
2401: p_before_after => 'B');
2402:
2403: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2404: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2405: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2406: RAISE OKC_API.G_EXCEPTION_ERROR;
2407: END IF;

Line 2404: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2400: p_procedure_name => l_api_name,
2401: p_before_after => 'B');
2402:
2403: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2404: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2405: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2406: RAISE OKC_API.G_EXCEPTION_ERROR;
2407: END IF;
2408:

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

2401: p_before_after => 'B');
2402:
2403: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2404: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2405: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2406: RAISE OKC_API.G_EXCEPTION_ERROR;
2407: END IF;
2408:
2409: --get values back from hook call

Line 2406: RAISE OKC_API.G_EXCEPTION_ERROR;

2402:
2403: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2404: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2405: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2406: RAISE OKC_API.G_EXCEPTION_ERROR;
2407: END IF;
2408:
2409: --get values back from hook call
2410: l_aavv_rec := migrate_aavv(l_aavv_rec, g_aavv_rec);

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

2416: x_msg_count => x_msg_count,
2417: x_msg_data => x_msg_data,
2418: p_aavv_rec => l_aavv_rec,
2419: x_aavv_rec => x_aavv_rec);
2420: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2421: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2422: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2423: RAISE OKC_API.G_EXCEPTION_ERROR;
2424: END IF;

Line 2421: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2417: x_msg_data => x_msg_data,
2418: p_aavv_rec => l_aavv_rec,
2419: x_aavv_rec => x_aavv_rec);
2420: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2421: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2422: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2423: RAISE OKC_API.G_EXCEPTION_ERROR;
2424: END IF;
2425:

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

2418: p_aavv_rec => l_aavv_rec,
2419: x_aavv_rec => x_aavv_rec);
2420: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2421: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2422: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2423: RAISE OKC_API.G_EXCEPTION_ERROR;
2424: END IF;
2425:
2426: --USER HOOK CALL FOR AFTER, STARTS

Line 2423: RAISE OKC_API.G_EXCEPTION_ERROR;

2419: x_aavv_rec => x_aavv_rec);
2420: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2421: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2422: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2423: RAISE OKC_API.G_EXCEPTION_ERROR;
2424: END IF;
2425:
2426: --USER HOOK CALL FOR AFTER, STARTS
2427: g_aavv_rec := x_aavv_rec;

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

2430: p_package_name => g_pkg_name,
2431: p_procedure_name => l_api_name,
2432: p_before_after => 'A');
2433:
2434: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2435: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2436: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2437: RAISE OKC_API.G_EXCEPTION_ERROR;
2438: END IF;

Line 2435: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2431: p_procedure_name => l_api_name,
2432: p_before_after => 'A');
2433:
2434: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2435: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2436: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2437: RAISE OKC_API.G_EXCEPTION_ERROR;
2438: END IF;
2439: --USER HOOK CALL FOR AFTER, ENDS

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

2432: p_before_after => 'A');
2433:
2434: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2435: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2436: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2437: RAISE OKC_API.G_EXCEPTION_ERROR;
2438: END IF;
2439: --USER HOOK CALL FOR AFTER, ENDS
2440:

Line 2437: RAISE OKC_API.G_EXCEPTION_ERROR;

2433:
2434: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2435: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2436: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2437: RAISE OKC_API.G_EXCEPTION_ERROR;
2438: END IF;
2439: --USER HOOK CALL FOR AFTER, ENDS
2440:
2441: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

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

2437: RAISE OKC_API.G_EXCEPTION_ERROR;
2438: END IF;
2439: --USER HOOK CALL FOR AFTER, ENDS
2440:
2441: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
2442:
2443: EXCEPTION
2444: WHEN OKC_API.G_EXCEPTION_ERROR THEN
2445: x_return_status := OKC_API.HANDLE_EXCEPTIONS

Line 2444: WHEN OKC_API.G_EXCEPTION_ERROR THEN

2440:
2441: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
2442:
2443: EXCEPTION
2444: WHEN OKC_API.G_EXCEPTION_ERROR THEN
2445: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2446: (
2447: l_api_name,
2448: G_PKG_NAME,

Line 2445: x_return_status := OKC_API.HANDLE_EXCEPTIONS

2441: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
2442:
2443: EXCEPTION
2444: WHEN OKC_API.G_EXCEPTION_ERROR THEN
2445: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2446: (
2447: l_api_name,
2448: G_PKG_NAME,
2449: 'OKC_API.G_RET_STS_ERROR',

Line 2449: 'OKC_API.G_RET_STS_ERROR',

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

Line 2455: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

2451: x_msg_data,
2452: '_PUB'
2453: );
2454:
2455: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
2456: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2457: (
2458: l_api_name,
2459: G_PKG_NAME,

Line 2456: x_return_status := OKC_API.HANDLE_EXCEPTIONS

2452: '_PUB'
2453: );
2454:
2455: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
2456: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2457: (
2458: l_api_name,
2459: G_PKG_NAME,
2460: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 2460: 'OKC_API.G_RET_STS_UNEXP_ERROR',

2456: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2457: (
2458: l_api_name,
2459: G_PKG_NAME,
2460: 'OKC_API.G_RET_STS_UNEXP_ERROR',
2461: x_msg_count,
2462: x_msg_data,
2463: '_PUB'
2464: );

Line 2467: x_return_status := OKC_API.HANDLE_EXCEPTIONS

2463: '_PUB'
2464: );
2465:
2466: WHEN OTHERS THEN
2467: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2468: (
2469: l_api_name,
2470: G_PKG_NAME,
2471: 'OTHERS',

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

2482: x_msg_data OUT NOCOPY VARCHAR2,
2483: p_aavv_tbl IN aavv_tbl_type,
2484: x_aavv_tbl OUT NOCOPY aavv_tbl_type) IS
2485:
2486: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2487: i NUMBER := 0;
2488: BEGIN
2489: --Initialize the return status
2490: x_return_status := OKC_API.G_RET_STS_SUCCESS;

Line 2490: x_return_status := OKC_API.G_RET_STS_SUCCESS;

2486: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2487: i NUMBER := 0;
2488: BEGIN
2489: --Initialize the return status
2490: x_return_status := OKC_API.G_RET_STS_SUCCESS;
2491:
2492: IF p_aavv_tbl.COUNT > 0 THEN
2493: i := p_aavv_tbl.FIRST;
2494: LOOP

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

2499: x_msg_count,
2500: x_msg_data,
2501: p_aavv_tbl(i),
2502: x_aavv_tbl(i));
2503: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2504: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2505: x_return_status := l_return_status;
2506: raise G_EXCEPTION_HALT_VALIDATION;
2507: ELSE

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

2500: x_msg_data,
2501: p_aavv_tbl(i),
2502: x_aavv_tbl(i));
2503: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2504: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2505: x_return_status := l_return_status;
2506: raise G_EXCEPTION_HALT_VALIDATION;
2507: ELSE
2508: x_return_status := l_return_status;

Line 2520: OKC_API.set_message(p_app_name => g_app_name,

2516: WHEN G_EXCEPTION_HALT_VALIDATION THEN
2517: NULL;
2518:
2519: WHEN OTHERS THEN
2520: OKC_API.set_message(p_app_name => g_app_name,
2521: p_msg_name => g_unexpected_error,
2522: p_token1 => g_sqlcode_token,
2523: p_token1_value => sqlcode,
2524: p_token2 => g_sqlerrm_token,

Line 2526: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

2522: p_token1 => g_sqlcode_token,
2523: p_token1_value => sqlcode,
2524: p_token2 => g_sqlerrm_token,
2525: p_token2_value => sqlerrm);
2526: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
2527: END create_act_att_vals;
2528:
2529:
2530: PROCEDURE delete_act_att_vals(p_api_version IN NUMBER,

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

2535: p_aavv_rec IN aavv_rec_type) IS
2536:
2537: l_api_name CONSTANT VARCHAR2(30) := 'delete_act_att_vals';
2538: l_api_version CONSTANT NUMBER := 1.0;
2539: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2540: l_aavv_rec aavv_rec_type := p_aavv_rec;
2541: BEGIN
2542: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
2543: g_pkg_name,

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

2538: l_api_version CONSTANT NUMBER := 1.0;
2539: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2540: l_aavv_rec aavv_rec_type := p_aavv_rec;
2541: BEGIN
2542: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
2543: g_pkg_name,
2544: p_init_msg_list,
2545: l_api_version,
2546: p_api_version,

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

2546: p_api_version,
2547: '_PUB',
2548: x_return_status);
2549:
2550: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2551: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2552: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2553: RAISE OKC_API.G_EXCEPTION_ERROR;
2554: END IF;

Line 2551: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2547: '_PUB',
2548: x_return_status);
2549:
2550: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2551: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2552: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2553: RAISE OKC_API.G_EXCEPTION_ERROR;
2554: END IF;
2555:

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

2548: x_return_status);
2549:
2550: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2551: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2552: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2553: RAISE OKC_API.G_EXCEPTION_ERROR;
2554: END IF;
2555:
2556: -- USER HOOK CALL FOR BEFORE, STARTS

Line 2553: RAISE OKC_API.G_EXCEPTION_ERROR;

2549:
2550: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2551: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2552: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2553: RAISE OKC_API.G_EXCEPTION_ERROR;
2554: END IF;
2555:
2556: -- USER HOOK CALL FOR BEFORE, STARTS
2557: g_aavv_rec := l_aavv_rec;

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

2559: okc_util.call_user_hook(x_return_status => x_return_status,
2560: p_package_name => g_pkg_name,
2561: p_procedure_name => l_api_name,
2562: p_before_after => 'B');
2563: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2564: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2565: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2566: RAISE OKC_API.G_EXCEPTION_ERROR;
2567: END IF;

Line 2564: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2560: p_package_name => g_pkg_name,
2561: p_procedure_name => l_api_name,
2562: p_before_after => 'B');
2563: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2564: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2565: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2566: RAISE OKC_API.G_EXCEPTION_ERROR;
2567: END IF;
2568:

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

2561: p_procedure_name => l_api_name,
2562: p_before_after => 'B');
2563: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2564: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2565: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2566: RAISE OKC_API.G_EXCEPTION_ERROR;
2567: END IF;
2568:
2569: --get values back from hook call

Line 2566: RAISE OKC_API.G_EXCEPTION_ERROR;

2562: p_before_after => 'B');
2563: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2564: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2565: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2566: RAISE OKC_API.G_EXCEPTION_ERROR;
2567: END IF;
2568:
2569: --get values back from hook call
2570: l_aavv_rec := migrate_aavv(l_aavv_rec, g_aavv_rec);

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

2575: x_return_status => x_return_status,
2576: x_msg_count => x_msg_count,
2577: x_msg_data => x_msg_data,
2578: p_aavv_rec => l_aavv_rec);
2579: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2580: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2581: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2582: RAISE OKC_API.G_EXCEPTION_ERROR;
2583: END IF;

Line 2580: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2576: x_msg_count => x_msg_count,
2577: x_msg_data => x_msg_data,
2578: p_aavv_rec => l_aavv_rec);
2579: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2580: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2581: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2582: RAISE OKC_API.G_EXCEPTION_ERROR;
2583: END IF;
2584:

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

2577: x_msg_data => x_msg_data,
2578: p_aavv_rec => l_aavv_rec);
2579: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2580: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2581: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2582: RAISE OKC_API.G_EXCEPTION_ERROR;
2583: END IF;
2584:
2585: --USER HOOK CALL FOR AFTER, STARTS

Line 2582: RAISE OKC_API.G_EXCEPTION_ERROR;

2578: p_aavv_rec => l_aavv_rec);
2579: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2580: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2581: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2582: RAISE OKC_API.G_EXCEPTION_ERROR;
2583: END IF;
2584:
2585: --USER HOOK CALL FOR AFTER, STARTS
2586: okc_util.call_user_hook(x_return_status => x_return_status,

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

2587: p_package_name => g_pkg_name,
2588: p_procedure_name => l_api_name,
2589: p_before_after => 'A');
2590:
2591: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2592: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2593: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2594: RAISE OKC_API.G_EXCEPTION_ERROR;
2595: END IF;

Line 2592: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2588: p_procedure_name => l_api_name,
2589: p_before_after => 'A');
2590:
2591: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2592: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2593: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2594: RAISE OKC_API.G_EXCEPTION_ERROR;
2595: END IF;
2596: --USER HOOK CALL FOR AFTER, ENDS

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

2589: p_before_after => 'A');
2590:
2591: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2592: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2593: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2594: RAISE OKC_API.G_EXCEPTION_ERROR;
2595: END IF;
2596: --USER HOOK CALL FOR AFTER, ENDS
2597:

Line 2594: RAISE OKC_API.G_EXCEPTION_ERROR;

2590:
2591: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2592: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2593: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2594: RAISE OKC_API.G_EXCEPTION_ERROR;
2595: END IF;
2596: --USER HOOK CALL FOR AFTER, ENDS
2597:
2598: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

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

2594: RAISE OKC_API.G_EXCEPTION_ERROR;
2595: END IF;
2596: --USER HOOK CALL FOR AFTER, ENDS
2597:
2598: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
2599: EXCEPTION
2600: WHEN OKC_API.G_EXCEPTION_ERROR THEN
2601: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2602: (

Line 2600: WHEN OKC_API.G_EXCEPTION_ERROR THEN

2596: --USER HOOK CALL FOR AFTER, ENDS
2597:
2598: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
2599: EXCEPTION
2600: WHEN OKC_API.G_EXCEPTION_ERROR THEN
2601: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2602: (
2603: l_api_name,
2604: G_PKG_NAME,

Line 2601: x_return_status := OKC_API.HANDLE_EXCEPTIONS

2597:
2598: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
2599: EXCEPTION
2600: WHEN OKC_API.G_EXCEPTION_ERROR THEN
2601: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2602: (
2603: l_api_name,
2604: G_PKG_NAME,
2605: 'OKC_API.G_RET_STS_ERROR',

Line 2605: 'OKC_API.G_RET_STS_ERROR',

2601: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2602: (
2603: l_api_name,
2604: G_PKG_NAME,
2605: 'OKC_API.G_RET_STS_ERROR',
2606: x_msg_count,
2607: x_msg_data,
2608: '_PUB'
2609: );

Line 2611: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

2607: x_msg_data,
2608: '_PUB'
2609: );
2610:
2611: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
2612: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2613: (
2614: l_api_name,
2615: G_PKG_NAME,

Line 2612: x_return_status := OKC_API.HANDLE_EXCEPTIONS

2608: '_PUB'
2609: );
2610:
2611: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
2612: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2613: (
2614: l_api_name,
2615: G_PKG_NAME,
2616: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 2616: 'OKC_API.G_RET_STS_UNEXP_ERROR',

2612: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2613: (
2614: l_api_name,
2615: G_PKG_NAME,
2616: 'OKC_API.G_RET_STS_UNEXP_ERROR',
2617: x_msg_count,
2618: x_msg_data,
2619: '_PUB'
2620: );

Line 2623: x_return_status := OKC_API.HANDLE_EXCEPTIONS

2619: '_PUB'
2620: );
2621:
2622: WHEN OTHERS THEN
2623: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2624: (
2625: l_api_name,
2626: G_PKG_NAME,
2627: 'OTHERS',

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

2637: x_msg_count OUT NOCOPY NUMBER,
2638: x_msg_data OUT NOCOPY VARCHAR2,
2639: p_aavv_tbl IN aavv_tbl_type) IS
2640:
2641: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2642: i NUMBER := 0;
2643: BEGIN
2644: --Initialize the return status
2645: x_return_status := OKC_API.G_RET_STS_SUCCESS;

Line 2645: x_return_status := OKC_API.G_RET_STS_SUCCESS;

2641: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2642: i NUMBER := 0;
2643: BEGIN
2644: --Initialize the return status
2645: x_return_status := OKC_API.G_RET_STS_SUCCESS;
2646:
2647: IF p_aavv_tbl.COUNT > 0 THEN
2648: i := p_aavv_tbl.FIRST;
2649: LOOP

Line 2657: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN

2653: x_return_status,
2654: x_msg_count,
2655: x_msg_data,
2656: p_aavv_tbl(i));
2657: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2658: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN -- need to leave
2659: l_return_status := x_return_status;
2660: RAISE G_EXCEPTION_HALT_VALIDATION;
2661: ELSE

Line 2658: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN -- need to leave

2654: x_msg_count,
2655: x_msg_data,
2656: p_aavv_tbl(i));
2657: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2658: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN -- need to leave
2659: l_return_status := x_return_status;
2660: RAISE G_EXCEPTION_HALT_VALIDATION;
2661: ELSE
2662: l_return_status := x_return_status; -- record that there was an error

Line 2674: OKC_API.set_message(p_app_name => g_app_name,

2670: WHEN G_EXCEPTION_HALT_VALIDATION THEN
2671: NULL;
2672:
2673: WHEN OTHERS THEN
2674: OKC_API.set_message(p_app_name => g_app_name,
2675: p_msg_name => g_unexpected_error,
2676: p_token1 => g_sqlcode_token,
2677: p_token1_value => sqlcode,
2678: p_token2 => g_sqlerrm_token,

Line 2680: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

2676: p_token1 => g_sqlcode_token,
2677: p_token1_value => sqlcode,
2678: p_token2 => g_sqlerrm_token,
2679: p_token2_value => sqlerrm);
2680: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
2681: END delete_act_att_vals;
2682:
2683: PROCEDURE validate_act_att_vals(p_api_version IN NUMBER,
2684: p_init_msg_list IN VARCHAR2 ,

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

2688: p_aavv_rec IN aavv_rec_type) IS
2689:
2690: l_api_name CONSTANT VARCHAR2(30) := 'validate_act_att_vals';
2691: l_api_version CONSTANT NUMBER := 1.0;
2692: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2693: l_aavv_rec aavv_rec_type := p_aavv_rec;
2694: BEGIN
2695: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
2696: g_pkg_name,

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

2691: l_api_version CONSTANT NUMBER := 1.0;
2692: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2693: l_aavv_rec aavv_rec_type := p_aavv_rec;
2694: BEGIN
2695: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
2696: g_pkg_name,
2697: p_init_msg_list,
2698: l_api_version,
2699: p_api_version,

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

2699: p_api_version,
2700: '_PUB',
2701: x_return_status);
2702:
2703: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2704: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2705: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2706: RAISE OKC_API.G_EXCEPTION_ERROR;
2707: END IF;

Line 2704: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2700: '_PUB',
2701: x_return_status);
2702:
2703: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2704: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2705: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2706: RAISE OKC_API.G_EXCEPTION_ERROR;
2707: END IF;
2708:

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

2701: x_return_status);
2702:
2703: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2704: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2705: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2706: RAISE OKC_API.G_EXCEPTION_ERROR;
2707: END IF;
2708:
2709: -- USER HOOK CALL FOR BEFORE, STARTS

Line 2706: RAISE OKC_API.G_EXCEPTION_ERROR;

2702:
2703: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2704: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2705: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2706: RAISE OKC_API.G_EXCEPTION_ERROR;
2707: END IF;
2708:
2709: -- USER HOOK CALL FOR BEFORE, STARTS
2710: g_aavv_rec := l_aavv_rec;

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

2712: okc_util.call_user_hook(x_return_status => x_return_status,
2713: p_package_name => g_pkg_name,
2714: p_procedure_name => l_api_name,
2715: p_before_after => 'B');
2716: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2717: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2718: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2719: RAISE OKC_API.G_EXCEPTION_ERROR;
2720: END IF;

Line 2717: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2713: p_package_name => g_pkg_name,
2714: p_procedure_name => l_api_name,
2715: p_before_after => 'B');
2716: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2717: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2718: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2719: RAISE OKC_API.G_EXCEPTION_ERROR;
2720: END IF;
2721:

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

2714: p_procedure_name => l_api_name,
2715: p_before_after => 'B');
2716: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2717: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2718: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2719: RAISE OKC_API.G_EXCEPTION_ERROR;
2720: END IF;
2721:
2722: --get values back from hook call

Line 2719: RAISE OKC_API.G_EXCEPTION_ERROR;

2715: p_before_after => 'B');
2716: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2717: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2718: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2719: RAISE OKC_API.G_EXCEPTION_ERROR;
2720: END IF;
2721:
2722: --get values back from hook call
2723: l_aavv_rec := migrate_aavv(l_aavv_rec, g_aavv_rec);

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

2729: x_msg_count => x_msg_count,
2730: x_msg_data => x_msg_data,
2731: p_aavv_rec => l_aavv_rec);
2732:
2733: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2734: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2735: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2736: RAISE OKC_API.G_EXCEPTION_ERROR;
2737: END IF;

Line 2734: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2730: x_msg_data => x_msg_data,
2731: p_aavv_rec => l_aavv_rec);
2732:
2733: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2734: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2735: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2736: RAISE OKC_API.G_EXCEPTION_ERROR;
2737: END IF;
2738:

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

2731: p_aavv_rec => l_aavv_rec);
2732:
2733: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2734: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2735: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2736: RAISE OKC_API.G_EXCEPTION_ERROR;
2737: END IF;
2738:
2739: --USER HOOK CALL FOR AFTER, STARTS

Line 2736: RAISE OKC_API.G_EXCEPTION_ERROR;

2732:
2733: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2734: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2735: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2736: RAISE OKC_API.G_EXCEPTION_ERROR;
2737: END IF;
2738:
2739: --USER HOOK CALL FOR AFTER, STARTS
2740: okc_util.call_user_hook(x_return_status => x_return_status,

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

2740: okc_util.call_user_hook(x_return_status => x_return_status,
2741: p_package_name => g_pkg_name,
2742: p_procedure_name => l_api_name,
2743: p_before_after => 'A');
2744: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2745: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2746: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2747: RAISE OKC_API.G_EXCEPTION_ERROR;
2748: END IF;

Line 2745: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2741: p_package_name => g_pkg_name,
2742: p_procedure_name => l_api_name,
2743: p_before_after => 'A');
2744: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2745: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2746: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2747: RAISE OKC_API.G_EXCEPTION_ERROR;
2748: END IF;
2749: --USER HOOK CALL FOR AFTER, ENDS

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

2742: p_procedure_name => l_api_name,
2743: p_before_after => 'A');
2744: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2745: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2746: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2747: RAISE OKC_API.G_EXCEPTION_ERROR;
2748: END IF;
2749: --USER HOOK CALL FOR AFTER, ENDS
2750:

Line 2747: RAISE OKC_API.G_EXCEPTION_ERROR;

2743: p_before_after => 'A');
2744: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2745: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2746: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2747: RAISE OKC_API.G_EXCEPTION_ERROR;
2748: END IF;
2749: --USER HOOK CALL FOR AFTER, ENDS
2750:
2751: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

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

2747: RAISE OKC_API.G_EXCEPTION_ERROR;
2748: END IF;
2749: --USER HOOK CALL FOR AFTER, ENDS
2750:
2751: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
2752:
2753: EXCEPTION
2754: WHEN OKC_API.G_EXCEPTION_ERROR THEN
2755: x_return_status := OKC_API.HANDLE_EXCEPTIONS

Line 2754: WHEN OKC_API.G_EXCEPTION_ERROR THEN

2750:
2751: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
2752:
2753: EXCEPTION
2754: WHEN OKC_API.G_EXCEPTION_ERROR THEN
2755: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2756: (
2757: l_api_name,
2758: G_PKG_NAME,

Line 2755: x_return_status := OKC_API.HANDLE_EXCEPTIONS

2751: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
2752:
2753: EXCEPTION
2754: WHEN OKC_API.G_EXCEPTION_ERROR THEN
2755: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2756: (
2757: l_api_name,
2758: G_PKG_NAME,
2759: 'OKC_API.G_RET_STS_ERROR',

Line 2759: 'OKC_API.G_RET_STS_ERROR',

2755: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2756: (
2757: l_api_name,
2758: G_PKG_NAME,
2759: 'OKC_API.G_RET_STS_ERROR',
2760: x_msg_count,
2761: x_msg_data,
2762: '_PUB'
2763: );

Line 2765: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

2761: x_msg_data,
2762: '_PUB'
2763: );
2764:
2765: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
2766: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2767: (
2768: l_api_name,
2769: G_PKG_NAME,

Line 2766: x_return_status := OKC_API.HANDLE_EXCEPTIONS

2762: '_PUB'
2763: );
2764:
2765: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
2766: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2767: (
2768: l_api_name,
2769: G_PKG_NAME,
2770: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 2770: 'OKC_API.G_RET_STS_UNEXP_ERROR',

2766: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2767: (
2768: l_api_name,
2769: G_PKG_NAME,
2770: 'OKC_API.G_RET_STS_UNEXP_ERROR',
2771: x_msg_count,
2772: x_msg_data,
2773: '_PUB'
2774: );

Line 2777: x_return_status := OKC_API.HANDLE_EXCEPTIONS

2773: '_PUB'
2774: );
2775:
2776: WHEN OTHERS THEN
2777: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2778: (
2779: l_api_name,
2780: G_PKG_NAME,
2781: 'OTHERS',

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

2791: x_msg_count OUT NOCOPY NUMBER,
2792: x_msg_data OUT NOCOPY VARCHAR2,
2793: p_aavv_tbl IN aavv_tbl_type) IS
2794:
2795: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2796: i NUMBER := 0;
2797: BEGIN
2798: --Initialize the return status
2799: x_return_status := OKC_API.G_RET_STS_SUCCESS;

Line 2799: x_return_status := OKC_API.G_RET_STS_SUCCESS;

2795: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2796: i NUMBER := 0;
2797: BEGIN
2798: --Initialize the return status
2799: x_return_status := OKC_API.G_RET_STS_SUCCESS;
2800:
2801: IF p_aavv_tbl.COUNT > 0 THEN
2802: i := p_aavv_tbl.FIRST;
2803: LOOP

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

2807: l_return_status,
2808: x_msg_count,
2809: x_msg_data,
2810: p_aavv_tbl(i));
2811: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2812: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2813: x_return_status := l_return_status;
2814: raise G_EXCEPTION_HALT_VALIDATION;
2815: ELSE

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

2808: x_msg_count,
2809: x_msg_data,
2810: p_aavv_tbl(i));
2811: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2812: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2813: x_return_status := l_return_status;
2814: raise G_EXCEPTION_HALT_VALIDATION;
2815: ELSE
2816: x_return_status := l_return_status;

Line 2828: OKC_API.set_message(p_app_name => g_app_name,

2824: WHEN G_EXCEPTION_HALT_VALIDATION THEN
2825: NULL;
2826:
2827: WHEN OTHERS THEN
2828: OKC_API.set_message(p_app_name => g_app_name,
2829: p_msg_name => g_unexpected_error,
2830: p_token1 => g_sqlcode_token,
2831: p_token1_value => sqlcode,
2832: p_token2 => g_sqlerrm_token,

Line 2834: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

2830: p_token1 => g_sqlcode_token,
2831: p_token1_value => sqlcode,
2832: p_token2 => g_sqlerrm_token,
2833: p_token2_value => sqlerrm);
2834: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
2835: END validate_act_att_vals;
2836:
2837: --Procedures for Action Attribute Lookups
2838:

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

2845: x_aalv_rec OUT NOCOPY aalv_rec_type) IS
2846:
2847: l_api_name CONSTANT VARCHAR2(30) := 'create_act_att_lkps';
2848: l_api_version CONSTANT NUMBER := 1.0;
2849: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2850: l_aalv_rec aalv_rec_type := p_aalv_rec;
2851: BEGIN
2852: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
2853: g_pkg_name,

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

2848: l_api_version CONSTANT NUMBER := 1.0;
2849: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2850: l_aalv_rec aalv_rec_type := p_aalv_rec;
2851: BEGIN
2852: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
2853: g_pkg_name,
2854: p_init_msg_list,
2855: l_api_version,
2856: p_api_version,

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

2856: p_api_version,
2857: '_PUB',
2858: x_return_status);
2859:
2860: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2861: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2862: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2863: RAISE OKC_API.G_EXCEPTION_ERROR;
2864: END IF;

Line 2861: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2857: '_PUB',
2858: x_return_status);
2859:
2860: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2861: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2862: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2863: RAISE OKC_API.G_EXCEPTION_ERROR;
2864: END IF;
2865:

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

2858: x_return_status);
2859:
2860: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2861: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2862: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2863: RAISE OKC_API.G_EXCEPTION_ERROR;
2864: END IF;
2865:
2866: -- USER HOOK CALL FOR BEFORE, STARTS

Line 2863: RAISE OKC_API.G_EXCEPTION_ERROR;

2859:
2860: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2861: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2862: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2863: RAISE OKC_API.G_EXCEPTION_ERROR;
2864: END IF;
2865:
2866: -- USER HOOK CALL FOR BEFORE, STARTS
2867: g_aalv_rec := l_aalv_rec;

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

2870: p_package_name => g_pkg_name,
2871: p_procedure_name => l_api_name,
2872: p_before_after => 'B');
2873:
2874: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2875: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2876: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2877: RAISE OKC_API.G_EXCEPTION_ERROR;
2878: END IF;

Line 2875: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2871: p_procedure_name => l_api_name,
2872: p_before_after => 'B');
2873:
2874: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2875: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2876: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2877: RAISE OKC_API.G_EXCEPTION_ERROR;
2878: END IF;
2879:

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

2872: p_before_after => 'B');
2873:
2874: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2875: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2876: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2877: RAISE OKC_API.G_EXCEPTION_ERROR;
2878: END IF;
2879:
2880: --get values back from hook call

Line 2877: RAISE OKC_API.G_EXCEPTION_ERROR;

2873:
2874: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2875: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2876: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2877: RAISE OKC_API.G_EXCEPTION_ERROR;
2878: END IF;
2879:
2880: --get values back from hook call
2881: l_aalv_rec := migrate_aalv(l_aalv_rec, g_aalv_rec);

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

2887: x_msg_count => x_msg_count,
2888: x_msg_data => x_msg_data,
2889: p_aalv_rec => l_aalv_rec,
2890: x_aalv_rec => x_aalv_rec);
2891: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2892: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2893: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2894: RAISE OKC_API.G_EXCEPTION_ERROR;
2895: END IF;

Line 2892: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2888: x_msg_data => x_msg_data,
2889: p_aalv_rec => l_aalv_rec,
2890: x_aalv_rec => x_aalv_rec);
2891: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2892: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2893: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2894: RAISE OKC_API.G_EXCEPTION_ERROR;
2895: END IF;
2896:

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

2889: p_aalv_rec => l_aalv_rec,
2890: x_aalv_rec => x_aalv_rec);
2891: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2892: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2893: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2894: RAISE OKC_API.G_EXCEPTION_ERROR;
2895: END IF;
2896:
2897: --USER HOOK CALL FOR AFTER, STARTS

Line 2894: RAISE OKC_API.G_EXCEPTION_ERROR;

2890: x_aalv_rec => x_aalv_rec);
2891: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2892: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2893: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2894: RAISE OKC_API.G_EXCEPTION_ERROR;
2895: END IF;
2896:
2897: --USER HOOK CALL FOR AFTER, STARTS
2898: g_aalv_rec := x_aalv_rec;

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

2901: p_package_name => g_pkg_name,
2902: p_procedure_name => l_api_name,
2903: p_before_after => 'A');
2904:
2905: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2906: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2907: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2908: RAISE OKC_API.G_EXCEPTION_ERROR;
2909: END IF;

Line 2906: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2902: p_procedure_name => l_api_name,
2903: p_before_after => 'A');
2904:
2905: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2906: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2907: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2908: RAISE OKC_API.G_EXCEPTION_ERROR;
2909: END IF;
2910: --USER HOOK CALL FOR AFTER, ENDS

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

2903: p_before_after => 'A');
2904:
2905: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2906: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2907: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2908: RAISE OKC_API.G_EXCEPTION_ERROR;
2909: END IF;
2910: --USER HOOK CALL FOR AFTER, ENDS
2911:

Line 2908: RAISE OKC_API.G_EXCEPTION_ERROR;

2904:
2905: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2906: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2907: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2908: RAISE OKC_API.G_EXCEPTION_ERROR;
2909: END IF;
2910: --USER HOOK CALL FOR AFTER, ENDS
2911:
2912: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

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

2908: RAISE OKC_API.G_EXCEPTION_ERROR;
2909: END IF;
2910: --USER HOOK CALL FOR AFTER, ENDS
2911:
2912: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
2913:
2914: EXCEPTION
2915: WHEN OKC_API.G_EXCEPTION_ERROR THEN
2916: x_return_status := OKC_API.HANDLE_EXCEPTIONS

Line 2915: WHEN OKC_API.G_EXCEPTION_ERROR THEN

2911:
2912: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
2913:
2914: EXCEPTION
2915: WHEN OKC_API.G_EXCEPTION_ERROR THEN
2916: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2917: (
2918: l_api_name,
2919: G_PKG_NAME,

Line 2916: x_return_status := OKC_API.HANDLE_EXCEPTIONS

2912: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
2913:
2914: EXCEPTION
2915: WHEN OKC_API.G_EXCEPTION_ERROR THEN
2916: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2917: (
2918: l_api_name,
2919: G_PKG_NAME,
2920: 'OKC_API.G_RET_STS_ERROR',

Line 2920: 'OKC_API.G_RET_STS_ERROR',

2916: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2917: (
2918: l_api_name,
2919: G_PKG_NAME,
2920: 'OKC_API.G_RET_STS_ERROR',
2921: x_msg_count,
2922: x_msg_data,
2923: '_PUB'
2924: );

Line 2926: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

2922: x_msg_data,
2923: '_PUB'
2924: );
2925:
2926: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
2927: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2928: (
2929: l_api_name,
2930: G_PKG_NAME,

Line 2927: x_return_status := OKC_API.HANDLE_EXCEPTIONS

2923: '_PUB'
2924: );
2925:
2926: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
2927: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2928: (
2929: l_api_name,
2930: G_PKG_NAME,
2931: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 2931: 'OKC_API.G_RET_STS_UNEXP_ERROR',

2927: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2928: (
2929: l_api_name,
2930: G_PKG_NAME,
2931: 'OKC_API.G_RET_STS_UNEXP_ERROR',
2932: x_msg_count,
2933: x_msg_data,
2934: '_PUB'
2935: );

Line 2938: x_return_status := OKC_API.HANDLE_EXCEPTIONS

2934: '_PUB'
2935: );
2936:
2937: WHEN OTHERS THEN
2938: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2939: (
2940: l_api_name,
2941: G_PKG_NAME,
2942: 'OTHERS',

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

2953: x_msg_data OUT NOCOPY VARCHAR2,
2954: p_aalv_tbl IN aalv_tbl_type,
2955: x_aalv_tbl OUT NOCOPY aalv_tbl_type) IS
2956:
2957: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2958: i NUMBER := 0;
2959: BEGIN
2960: --Initialize the return status
2961: x_return_status := OKC_API.G_RET_STS_SUCCESS;

Line 2961: x_return_status := OKC_API.G_RET_STS_SUCCESS;

2957: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2958: i NUMBER := 0;
2959: BEGIN
2960: --Initialize the return status
2961: x_return_status := OKC_API.G_RET_STS_SUCCESS;
2962:
2963: IF p_aalv_tbl.COUNT > 0 THEN
2964: i := p_aalv_tbl.FIRST;
2965: LOOP

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

2970: x_msg_count,
2971: x_msg_data,
2972: p_aalv_tbl(i),
2973: x_aalv_tbl(i));
2974: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2975: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2976: x_return_status := l_return_status;
2977: raise G_EXCEPTION_HALT_VALIDATION;
2978: ELSE

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

2971: x_msg_data,
2972: p_aalv_tbl(i),
2973: x_aalv_tbl(i));
2974: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2975: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2976: x_return_status := l_return_status;
2977: raise G_EXCEPTION_HALT_VALIDATION;
2978: ELSE
2979: x_return_status := l_return_status;

Line 2991: OKC_API.set_message(p_app_name => g_app_name,

2987: WHEN G_EXCEPTION_HALT_VALIDATION THEN
2988: NULL;
2989:
2990: WHEN OTHERS THEN
2991: OKC_API.set_message(p_app_name => g_app_name,
2992: p_msg_name => g_unexpected_error,
2993: p_token1 => g_sqlcode_token,
2994: p_token1_value => sqlcode,
2995: p_token2 => g_sqlerrm_token,

Line 2997: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

2993: p_token1 => g_sqlcode_token,
2994: p_token1_value => sqlcode,
2995: p_token2 => g_sqlerrm_token,
2996: p_token2_value => sqlerrm);
2997: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
2998: END create_act_att_lkps;
2999:
3000: PROCEDURE lock_act_att_lkps(p_api_version IN NUMBER,
3001: p_init_msg_list IN VARCHAR2 ,

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

3004: x_msg_data OUT NOCOPY VARCHAR2,
3005: p_aalv_rec IN aalv_rec_type) IS
3006: l_api_name CONSTANT VARCHAR2(30) := 'delete_act_att_lkps';
3007: l_api_version CONSTANT NUMBER := 1.0;
3008: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
3009: l_aalv_rec aalv_rec_type := p_aalv_rec;
3010: BEGIN
3011: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
3012: g_pkg_name,

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

3007: l_api_version CONSTANT NUMBER := 1.0;
3008: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
3009: l_aalv_rec aalv_rec_type := p_aalv_rec;
3010: BEGIN
3011: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
3012: g_pkg_name,
3013: p_init_msg_list,
3014: l_api_version,
3015: p_api_version,

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

3015: p_api_version,
3016: '_PUB',
3017: x_return_status);
3018:
3019: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3020: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3021: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
3022: RAISE OKC_API.G_EXCEPTION_ERROR;
3023: END IF;

Line 3020: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

3016: '_PUB',
3017: x_return_status);
3018:
3019: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3020: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3021: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
3022: RAISE OKC_API.G_EXCEPTION_ERROR;
3023: END IF;
3024:

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

3017: x_return_status);
3018:
3019: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3020: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3021: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
3022: RAISE OKC_API.G_EXCEPTION_ERROR;
3023: END IF;
3024:
3025: -- Call to procedure of complex API

Line 3022: RAISE OKC_API.G_EXCEPTION_ERROR;

3018:
3019: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3020: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3021: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
3022: RAISE OKC_API.G_EXCEPTION_ERROR;
3023: END IF;
3024:
3025: -- Call to procedure of complex API
3026: okc_conditions_pvt.lock_act_att_lkps(p_api_version => p_api_version,

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

3029: x_msg_count => x_msg_count,
3030: x_msg_data => x_msg_data,
3031: p_aalv_rec => l_aalv_rec);
3032:
3033: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3034: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3035: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3036: RAISE OKC_API.G_EXCEPTION_ERROR;
3037: END IF;

Line 3034: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

3030: x_msg_data => x_msg_data,
3031: p_aalv_rec => l_aalv_rec);
3032:
3033: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3034: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3035: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3036: RAISE OKC_API.G_EXCEPTION_ERROR;
3037: END IF;
3038:

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

3031: p_aalv_rec => l_aalv_rec);
3032:
3033: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3034: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3035: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3036: RAISE OKC_API.G_EXCEPTION_ERROR;
3037: END IF;
3038:
3039: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

Line 3036: RAISE OKC_API.G_EXCEPTION_ERROR;

3032:
3033: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3034: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3035: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3036: RAISE OKC_API.G_EXCEPTION_ERROR;
3037: END IF;
3038:
3039: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
3040:

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

3035: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3036: RAISE OKC_API.G_EXCEPTION_ERROR;
3037: END IF;
3038:
3039: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
3040:
3041: EXCEPTION
3042: WHEN OKC_API.G_EXCEPTION_ERROR THEN
3043: x_return_status := OKC_API.HANDLE_EXCEPTIONS

Line 3042: WHEN OKC_API.G_EXCEPTION_ERROR THEN

3038:
3039: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
3040:
3041: EXCEPTION
3042: WHEN OKC_API.G_EXCEPTION_ERROR THEN
3043: x_return_status := OKC_API.HANDLE_EXCEPTIONS
3044: (
3045: l_api_name,
3046: G_PKG_NAME,

Line 3043: x_return_status := OKC_API.HANDLE_EXCEPTIONS

3039: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
3040:
3041: EXCEPTION
3042: WHEN OKC_API.G_EXCEPTION_ERROR THEN
3043: x_return_status := OKC_API.HANDLE_EXCEPTIONS
3044: (
3045: l_api_name,
3046: G_PKG_NAME,
3047: 'OKC_API.G_RET_STS_ERROR',

Line 3047: 'OKC_API.G_RET_STS_ERROR',

3043: x_return_status := OKC_API.HANDLE_EXCEPTIONS
3044: (
3045: l_api_name,
3046: G_PKG_NAME,
3047: 'OKC_API.G_RET_STS_ERROR',
3048: x_msg_count,
3049: x_msg_data,
3050: '_PUB'
3051: );

Line 3053: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

3049: x_msg_data,
3050: '_PUB'
3051: );
3052:
3053: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
3054: x_return_status := OKC_API.HANDLE_EXCEPTIONS
3055: (
3056: l_api_name,
3057: G_PKG_NAME,

Line 3054: x_return_status := OKC_API.HANDLE_EXCEPTIONS

3050: '_PUB'
3051: );
3052:
3053: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
3054: x_return_status := OKC_API.HANDLE_EXCEPTIONS
3055: (
3056: l_api_name,
3057: G_PKG_NAME,
3058: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 3058: 'OKC_API.G_RET_STS_UNEXP_ERROR',

3054: x_return_status := OKC_API.HANDLE_EXCEPTIONS
3055: (
3056: l_api_name,
3057: G_PKG_NAME,
3058: 'OKC_API.G_RET_STS_UNEXP_ERROR',
3059: x_msg_count,
3060: x_msg_data,
3061: '_PUB'
3062: );

Line 3065: x_return_status := OKC_API.HANDLE_EXCEPTIONS

3061: '_PUB'
3062: );
3063:
3064: WHEN OTHERS THEN
3065: x_return_status := OKC_API.HANDLE_EXCEPTIONS
3066: (
3067: l_api_name,
3068: G_PKG_NAME,
3069: 'OTHERS',

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

3078: x_return_status OUT NOCOPY VARCHAR2,
3079: x_msg_count OUT NOCOPY NUMBER,
3080: x_msg_data OUT NOCOPY VARCHAR2,
3081: p_aalv_tbl IN aalv_tbl_type) IS
3082: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
3083: i NUMBER := 0;
3084: BEGIN
3085: x_return_status := OKC_API.G_RET_STS_SUCCESS;
3086: IF p_aalv_tbl.COUNT > 0 THEN

Line 3085: x_return_status := OKC_API.G_RET_STS_SUCCESS;

3081: p_aalv_tbl IN aalv_tbl_type) IS
3082: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
3083: i NUMBER := 0;
3084: BEGIN
3085: x_return_status := OKC_API.G_RET_STS_SUCCESS;
3086: IF p_aalv_tbl.COUNT > 0 THEN
3087: i := p_aalv_tbl.FIRST;
3088: LOOP
3089: lock_act_att_lkps(

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

3092: l_return_status,
3093: x_msg_count,
3094: x_msg_data,
3095: p_aalv_tbl(i));
3096: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
3097: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3098: x_return_status := l_return_status;
3099: raise G_EXCEPTION_HALT_VALIDATION;
3100: ELSE

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

3093: x_msg_count,
3094: x_msg_data,
3095: p_aalv_tbl(i));
3096: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
3097: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3098: x_return_status := l_return_status;
3099: raise G_EXCEPTION_HALT_VALIDATION;
3100: ELSE
3101: x_return_status := l_return_status;

Line 3113: OKC_API.set_message(p_app_name => g_app_name,

3109: WHEN G_EXCEPTION_HALT_VALIDATION THEN
3110: NULL;
3111:
3112: WHEN OTHERS THEN
3113: OKC_API.set_message(p_app_name => g_app_name,
3114: p_msg_name => g_unexpected_error,
3115: p_token1 => g_sqlcode_token,
3116: p_token1_value => sqlcode,
3117: p_token2 => g_sqlerrm_token,

Line 3119: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

3115: p_token1 => g_sqlcode_token,
3116: p_token1_value => sqlcode,
3117: p_token2 => g_sqlerrm_token,
3118: p_token2_value => sqlerrm);
3119: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
3120: End lock_act_att_lkps;
3121:
3122: PROCEDURE update_act_att_lkps(p_api_version IN NUMBER,
3123: p_init_msg_list IN VARCHAR2 ,

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

3128: x_aalv_rec OUT NOCOPY aalv_rec_type) IS
3129:
3130: l_api_name CONSTANT VARCHAR2(30) := 'update_act_att_lkps';
3131: l_api_version CONSTANT NUMBER := 1.0;
3132: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
3133: l_aalv_rec aalv_rec_type := p_aalv_rec;
3134: BEGIN
3135: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
3136: g_pkg_name,

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

3131: l_api_version CONSTANT NUMBER := 1.0;
3132: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
3133: l_aalv_rec aalv_rec_type := p_aalv_rec;
3134: BEGIN
3135: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
3136: g_pkg_name,
3137: p_init_msg_list,
3138: l_api_version,
3139: p_api_version,

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

3138: l_api_version,
3139: p_api_version,
3140: '_PUB',
3141: x_return_status);
3142: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3143: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3144: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
3145: RAISE OKC_API.G_EXCEPTION_ERROR;
3146: END IF;

Line 3143: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

3139: p_api_version,
3140: '_PUB',
3141: x_return_status);
3142: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3143: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3144: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
3145: RAISE OKC_API.G_EXCEPTION_ERROR;
3146: END IF;
3147:

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

3140: '_PUB',
3141: x_return_status);
3142: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3143: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3144: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
3145: RAISE OKC_API.G_EXCEPTION_ERROR;
3146: END IF;
3147:
3148: -- USER HOOK CALL FOR BEFORE, STARTS

Line 3145: RAISE OKC_API.G_EXCEPTION_ERROR;

3141: x_return_status);
3142: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3143: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3144: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
3145: RAISE OKC_API.G_EXCEPTION_ERROR;
3146: END IF;
3147:
3148: -- USER HOOK CALL FOR BEFORE, STARTS
3149: g_aalv_rec := l_aalv_rec;

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

3151: okc_util.call_user_hook(x_return_status => x_return_status,
3152: p_package_name => g_pkg_name,
3153: p_procedure_name => l_api_name,
3154: p_before_after => 'B');
3155: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3156: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3157: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3158: RAISE OKC_API.G_EXCEPTION_ERROR;
3159: END IF;

Line 3156: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

3152: p_package_name => g_pkg_name,
3153: p_procedure_name => l_api_name,
3154: p_before_after => 'B');
3155: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3156: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3157: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3158: RAISE OKC_API.G_EXCEPTION_ERROR;
3159: END IF;
3160:

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

3153: p_procedure_name => l_api_name,
3154: p_before_after => 'B');
3155: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3156: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3157: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3158: RAISE OKC_API.G_EXCEPTION_ERROR;
3159: END IF;
3160:
3161: --get values back from hook call

Line 3158: RAISE OKC_API.G_EXCEPTION_ERROR;

3154: p_before_after => 'B');
3155: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3156: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3157: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3158: RAISE OKC_API.G_EXCEPTION_ERROR;
3159: END IF;
3160:
3161: --get values back from hook call
3162: l_aalv_rec := migrate_aalv(l_aalv_rec, g_aalv_rec);