APPS.OKC_STD_ARTICLE_PUB dependencies on OKC_API

Line 156: x_return_status := OKC_API.G_RET_STS_SUCCESS;

152: x_savv_tbl OUT NOCOPY savv_tbl_type,
153: x_saiv_tbl OUT NOCOPY saiv_tbl_type,
154: x_samv_tbl OUT NOCOPY samv_tbl_type) IS
155: BEGIN
156: x_return_status := OKC_API.G_RET_STS_SUCCESS;
157: OKC_STD_ARTICLE_PVT.create_std_article(
158: p_api_version => p_api_version,
159: p_init_msg_list => p_init_msg_list,
160: x_return_status => x_return_status,

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

170: x_samv_tbl => x_samv_tbl);
171:
172: EXCEPTION
173: WHEN OTHERS THEN
174: OKC_API.set_message(p_app_name => g_app_name,
175: p_msg_name => g_unexpected_error,
176: p_token1 => g_sqlcode_token,
177: p_token1_value => sqlcode,
178: p_token2 => g_sqlerrm_token,

Line 180: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

176: p_token1 => g_sqlcode_token,
177: p_token1_value => sqlcode,
178: p_token2 => g_sqlerrm_token,
179: p_token2_value => sqlerrm);
180: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
181: END Create_std_article;
182:
183:
184:

Line 200: x_return_status := OKC_API.G_RET_STS_SUCCESS;

196: x_savv_tbl OUT NOCOPY savv_tbl_type,
197: x_saiv_tbl OUT NOCOPY saiv_tbl_type,
198: x_samv_tbl OUT NOCOPY samv_tbl_type) IS
199: BEGIN
200: x_return_status := OKC_API.G_RET_STS_SUCCESS;
201: OKC_STD_ARTICLE_PVT.update_std_article(
202: p_api_version => p_api_version,
203: p_init_msg_list => p_init_msg_list,
204: x_return_status => x_return_status,

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

214: x_samv_tbl => x_samv_tbl);
215:
216: EXCEPTION
217: WHEN OTHERS THEN
218: OKC_API.set_message(p_app_name => g_app_name,
219: p_msg_name => g_unexpected_error,
220: p_token1 => g_sqlcode_token,
221: p_token1_value => sqlcode,
222: p_token2 => g_sqlerrm_token,

Line 224: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

220: p_token1 => g_sqlcode_token,
221: p_token1_value => sqlcode,
222: p_token2 => g_sqlerrm_token,
223: p_token2_value => sqlerrm);
224: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
225: END Update_std_article;
226:
227:
228:

Line 240: x_return_status := OKC_API.G_RET_STS_SUCCESS;

236: p_savv_tbl IN savv_tbl_type,
237: p_saiv_tbl IN saiv_tbl_type,
238: p_samv_tbl IN samv_tbl_type) IS
239: BEGIN
240: x_return_status := OKC_API.G_RET_STS_SUCCESS;
241: OKC_STD_ARTICLE_PVT.validate_std_article(
242: p_api_version => p_api_version,
243: p_init_msg_list => p_init_msg_list,
244: x_return_status => x_return_status,

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

250: p_samv_tbl => p_samv_tbl);
251:
252: EXCEPTION
253: WHEN OTHERS THEN
254: OKC_API.set_message(p_app_name => g_app_name,
255: p_msg_name => g_unexpected_error,
256: p_token1 => g_sqlcode_token,
257: p_token1_value => sqlcode,
258: p_token2 => g_sqlerrm_token,

Line 260: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

256: p_token1 => g_sqlcode_token,
257: p_token1_value => sqlcode,
258: p_token2 => g_sqlerrm_token,
259: p_token2_value => sqlerrm);
260: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
261:
262: END Validate_std_article;
263:
264:

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

270: x_msg_count OUT NOCOPY NUMBER,
271: x_msg_data OUT NOCOPY VARCHAR2,
272: p_saev_rec IN saev_rec_type,
273: x_saev_rec OUT NOCOPY saev_rec_type) IS
274: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
275: l_api_name CONSTANT VARCHAR2(30) := 'CREATE_STD_ARTICLE';
276: l_saev_rec saev_rec_type := p_saev_rec;
277: BEGIN
278: l_return_status := OKC_API.START_ACTIVITY(l_api_name,

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

274: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
275: l_api_name CONSTANT VARCHAR2(30) := 'CREATE_STD_ARTICLE';
276: l_saev_rec saev_rec_type := p_saev_rec;
277: BEGIN
278: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
279: p_init_msg_list,
280: '_PUB',
281: x_return_status);
282: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

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

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

Line 283: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

279: p_init_msg_list,
280: '_PUB',
281: x_return_status);
282: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
283: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
284: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
285: raise OKC_API.G_EXCEPTION_ERROR;
286: END IF;
287: -- Call user hook for BEFORE

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

280: '_PUB',
281: x_return_status);
282: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
283: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
284: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
285: raise OKC_API.G_EXCEPTION_ERROR;
286: END IF;
287: -- Call user hook for BEFORE
288: g_saev_rec := l_saev_rec;

Line 285: raise OKC_API.G_EXCEPTION_ERROR;

281: x_return_status);
282: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
283: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
284: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
285: raise OKC_API.G_EXCEPTION_ERROR;
286: END IF;
287: -- Call user hook for BEFORE
288: g_saev_rec := l_saev_rec;
289: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');

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

286: END IF;
287: -- Call user hook for BEFORE
288: g_saev_rec := l_saev_rec;
289: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
290: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
291: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
292: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
293: raise OKC_API.G_EXCEPTION_ERROR;
294: END IF;

Line 291: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

287: -- Call user hook for BEFORE
288: g_saev_rec := l_saev_rec;
289: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
290: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
291: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
292: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
293: raise OKC_API.G_EXCEPTION_ERROR;
294: END IF;
295: l_saev_rec := migrate_saev(l_saev_rec, g_saev_rec);

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

288: g_saev_rec := l_saev_rec;
289: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
290: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
291: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
292: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
293: raise OKC_API.G_EXCEPTION_ERROR;
294: END IF;
295: l_saev_rec := migrate_saev(l_saev_rec, g_saev_rec);
296:

Line 293: raise OKC_API.G_EXCEPTION_ERROR;

289: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
290: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
291: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
292: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
293: raise OKC_API.G_EXCEPTION_ERROR;
294: END IF;
295: l_saev_rec := migrate_saev(l_saev_rec, g_saev_rec);
296:
297: OKC_STD_ARTICLE_PVT.create_std_article(

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

302: x_msg_data => x_msg_data,
303: p_saev_rec => l_saev_rec,
304: x_saev_rec => x_saev_rec);
305:
306: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
307: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
308: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
309: raise OKC_API.G_EXCEPTION_ERROR;
310: END IF;

Line 307: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

303: p_saev_rec => l_saev_rec,
304: x_saev_rec => x_saev_rec);
305:
306: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
307: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
308: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
309: raise OKC_API.G_EXCEPTION_ERROR;
310: END IF;
311:

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

304: x_saev_rec => x_saev_rec);
305:
306: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
307: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
308: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
309: raise OKC_API.G_EXCEPTION_ERROR;
310: END IF;
311:
312: -- Call user hook for AFTER

Line 309: raise OKC_API.G_EXCEPTION_ERROR;

305:
306: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
307: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
308: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
309: raise OKC_API.G_EXCEPTION_ERROR;
310: END IF;
311:
312: -- Call user hook for AFTER
313: g_saev_rec := x_saev_rec;

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

311:
312: -- Call user hook for AFTER
313: g_saev_rec := x_saev_rec;
314: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
315: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
316: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
317: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
318: raise OKC_API.G_EXCEPTION_ERROR;
319: END IF;

Line 316: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

312: -- Call user hook for AFTER
313: g_saev_rec := x_saev_rec;
314: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
315: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
316: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
317: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
318: raise OKC_API.G_EXCEPTION_ERROR;
319: END IF;
320: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

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

313: g_saev_rec := x_saev_rec;
314: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
315: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
316: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
317: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
318: raise OKC_API.G_EXCEPTION_ERROR;
319: END IF;
320: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
321: EXCEPTION

Line 318: raise OKC_API.G_EXCEPTION_ERROR;

314: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
315: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
316: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
317: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
318: raise OKC_API.G_EXCEPTION_ERROR;
319: END IF;
320: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
321: EXCEPTION
322: WHEN OKC_API.G_EXCEPTION_ERROR THEN

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

316: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
317: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
318: raise OKC_API.G_EXCEPTION_ERROR;
319: END IF;
320: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
321: EXCEPTION
322: WHEN OKC_API.G_EXCEPTION_ERROR THEN
323: x_return_status := OKC_API.HANDLE_EXCEPTIONS
324: (l_api_name,

Line 322: WHEN OKC_API.G_EXCEPTION_ERROR THEN

318: raise OKC_API.G_EXCEPTION_ERROR;
319: END IF;
320: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
321: EXCEPTION
322: WHEN OKC_API.G_EXCEPTION_ERROR THEN
323: x_return_status := OKC_API.HANDLE_EXCEPTIONS
324: (l_api_name,
325: G_PKG_NAME,
326: 'OKC_API.G_RET_STS_ERROR',

Line 323: x_return_status := OKC_API.HANDLE_EXCEPTIONS

319: END IF;
320: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
321: EXCEPTION
322: WHEN OKC_API.G_EXCEPTION_ERROR THEN
323: x_return_status := OKC_API.HANDLE_EXCEPTIONS
324: (l_api_name,
325: G_PKG_NAME,
326: 'OKC_API.G_RET_STS_ERROR',
327: x_msg_count,

Line 326: 'OKC_API.G_RET_STS_ERROR',

322: WHEN OKC_API.G_EXCEPTION_ERROR THEN
323: x_return_status := OKC_API.HANDLE_EXCEPTIONS
324: (l_api_name,
325: G_PKG_NAME,
326: 'OKC_API.G_RET_STS_ERROR',
327: x_msg_count,
328: x_msg_data,
329: '_PUB');
330: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

Line 330: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

326: 'OKC_API.G_RET_STS_ERROR',
327: x_msg_count,
328: x_msg_data,
329: '_PUB');
330: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
331: x_return_status := OKC_API.HANDLE_EXCEPTIONS
332: (l_api_name,
333: G_PKG_NAME,
334: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 331: x_return_status := OKC_API.HANDLE_EXCEPTIONS

327: x_msg_count,
328: x_msg_data,
329: '_PUB');
330: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
331: x_return_status := OKC_API.HANDLE_EXCEPTIONS
332: (l_api_name,
333: G_PKG_NAME,
334: 'OKC_API.G_RET_STS_UNEXP_ERROR',
335: x_msg_count,

Line 334: 'OKC_API.G_RET_STS_UNEXP_ERROR',

330: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
331: x_return_status := OKC_API.HANDLE_EXCEPTIONS
332: (l_api_name,
333: G_PKG_NAME,
334: 'OKC_API.G_RET_STS_UNEXP_ERROR',
335: x_msg_count,
336: x_msg_data,
337: '_PUB');
338: WHEN OTHERS THEN

Line 339: x_return_status := OKC_API.HANDLE_EXCEPTIONS

335: x_msg_count,
336: x_msg_data,
337: '_PUB');
338: WHEN OTHERS THEN
339: x_return_status := OKC_API.HANDLE_EXCEPTIONS
340: (l_api_name,
341: G_PKG_NAME,
342: 'OTHERS',
343: x_msg_count,

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

353: x_msg_data OUT NOCOPY VARCHAR2,
354: p_saev_tbl IN saev_tbl_type,
355: x_saev_tbl OUT NOCOPY saev_tbl_type) IS
356: i NUMBER := 0;
357: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
358:
359: BEGIN
360: x_return_status := OKC_API.G_RET_STS_SUCCESS;
361: IF p_saev_tbl.COUNT > 0 THEN

Line 360: x_return_status := OKC_API.G_RET_STS_SUCCESS;

356: i NUMBER := 0;
357: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
358:
359: BEGIN
360: x_return_status := OKC_API.G_RET_STS_SUCCESS;
361: IF p_saev_tbl.COUNT > 0 THEN
362: i := p_saev_tbl.FIRST;
363: LOOP
364: create_std_article(

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

368: x_msg_count => x_msg_count,
369: x_msg_data => x_msg_data,
370: p_saev_rec => p_saev_tbl(i),
371: x_saev_rec => x_saev_tbl(i));
372: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
373: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
374: x_return_status := l_return_status;
375: raise G_EXCEPTION_HALT_PROCESSING;
376: ELSE

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

369: x_msg_data => x_msg_data,
370: p_saev_rec => p_saev_tbl(i),
371: x_saev_rec => x_saev_tbl(i));
372: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
373: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
374: x_return_status := l_return_status;
375: raise G_EXCEPTION_HALT_PROCESSING;
376: ELSE
377: x_return_status := l_return_status;

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

384: EXCEPTION
385: WHEN G_EXCEPTION_HALT_PROCESSING THEN
386: NULL;
387: WHEN OTHERS THEN
388: OKC_API.set_message(p_app_name => g_app_name,
389: p_msg_name => g_unexpected_error,
390: p_token1 => g_sqlcode_token,
391: p_token1_value => sqlcode,
392: p_token2 => g_sqlerrm_token,

Line 394: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

390: p_token1 => g_sqlcode_token,
391: p_token1_value => sqlcode,
392: p_token2 => g_sqlerrm_token,
393: p_token2_value => sqlerrm);
394: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
395: END Create_std_article;
396:
397:
398: PROCEDURE update_std_article(

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

402: x_msg_count OUT NOCOPY NUMBER,
403: x_msg_data OUT NOCOPY VARCHAR2,
404: p_saev_rec IN saev_rec_type,
405: x_saev_rec OUT NOCOPY saev_rec_type) IS
406: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
407: l_api_name CONSTANT VARCHAR2(30) := 'UPDATE_STD_ARTICLE';
408: l_saev_rec saev_rec_type := p_saev_rec;
409: BEGIN
410: l_return_status := OKC_API.START_ACTIVITY(l_api_name,

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

406: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
407: l_api_name CONSTANT VARCHAR2(30) := 'UPDATE_STD_ARTICLE';
408: l_saev_rec saev_rec_type := p_saev_rec;
409: BEGIN
410: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
411: p_init_msg_list,
412: '_PUB',
413: x_return_status);
414: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

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

410: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
411: p_init_msg_list,
412: '_PUB',
413: x_return_status);
414: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
415: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
416: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
417: raise OKC_API.G_EXCEPTION_ERROR;
418: END IF;

Line 415: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

411: p_init_msg_list,
412: '_PUB',
413: x_return_status);
414: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
415: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
416: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
417: raise OKC_API.G_EXCEPTION_ERROR;
418: END IF;
419: -- Call user hook for BEFORE

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

412: '_PUB',
413: x_return_status);
414: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
415: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
416: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
417: raise OKC_API.G_EXCEPTION_ERROR;
418: END IF;
419: -- Call user hook for BEFORE
420: g_saev_rec := l_saev_rec;

Line 417: raise OKC_API.G_EXCEPTION_ERROR;

413: x_return_status);
414: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
415: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
416: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
417: raise OKC_API.G_EXCEPTION_ERROR;
418: END IF;
419: -- Call user hook for BEFORE
420: g_saev_rec := l_saev_rec;
421: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');

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

418: END IF;
419: -- Call user hook for BEFORE
420: g_saev_rec := l_saev_rec;
421: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
422: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
423: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
424: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
425: raise OKC_API.G_EXCEPTION_ERROR;
426: END IF;

Line 423: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

419: -- Call user hook for BEFORE
420: g_saev_rec := l_saev_rec;
421: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
422: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
423: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
424: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
425: raise OKC_API.G_EXCEPTION_ERROR;
426: END IF;
427: l_saev_rec := migrate_saev(l_saev_rec, g_saev_rec);

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

420: g_saev_rec := l_saev_rec;
421: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
422: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
423: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
424: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
425: raise OKC_API.G_EXCEPTION_ERROR;
426: END IF;
427: l_saev_rec := migrate_saev(l_saev_rec, g_saev_rec);
428:

Line 425: raise OKC_API.G_EXCEPTION_ERROR;

421: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
422: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
423: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
424: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
425: raise OKC_API.G_EXCEPTION_ERROR;
426: END IF;
427: l_saev_rec := migrate_saev(l_saev_rec, g_saev_rec);
428:
429: OKC_STD_ARTICLE_PVT.update_std_article(

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

434: x_msg_data => x_msg_data,
435: p_saev_rec => l_saev_rec,
436: x_saev_rec => x_saev_rec);
437:
438: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
439: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
440: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
441: raise OKC_API.G_EXCEPTION_ERROR;
442: END IF;

Line 439: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

435: p_saev_rec => l_saev_rec,
436: x_saev_rec => x_saev_rec);
437:
438: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
439: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
440: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
441: raise OKC_API.G_EXCEPTION_ERROR;
442: END IF;
443:

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

436: x_saev_rec => x_saev_rec);
437:
438: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
439: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
440: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
441: raise OKC_API.G_EXCEPTION_ERROR;
442: END IF;
443:
444: -- Call user hook for AFTER

Line 441: raise OKC_API.G_EXCEPTION_ERROR;

437:
438: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
439: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
440: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
441: raise OKC_API.G_EXCEPTION_ERROR;
442: END IF;
443:
444: -- Call user hook for AFTER
445: g_saev_rec := x_saev_rec;

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

443:
444: -- Call user hook for AFTER
445: g_saev_rec := x_saev_rec;
446: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
447: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
448: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
449: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
450: raise OKC_API.G_EXCEPTION_ERROR;
451: END IF;

Line 448: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

444: -- Call user hook for AFTER
445: g_saev_rec := x_saev_rec;
446: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
447: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
448: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
449: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
450: raise OKC_API.G_EXCEPTION_ERROR;
451: END IF;
452: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

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

445: g_saev_rec := x_saev_rec;
446: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
447: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
448: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
449: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
450: raise OKC_API.G_EXCEPTION_ERROR;
451: END IF;
452: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
453: EXCEPTION

Line 450: raise OKC_API.G_EXCEPTION_ERROR;

446: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
447: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
448: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
449: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
450: raise OKC_API.G_EXCEPTION_ERROR;
451: END IF;
452: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
453: EXCEPTION
454: WHEN OKC_API.G_EXCEPTION_ERROR THEN

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

448: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
449: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
450: raise OKC_API.G_EXCEPTION_ERROR;
451: END IF;
452: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
453: EXCEPTION
454: WHEN OKC_API.G_EXCEPTION_ERROR THEN
455: x_return_status := OKC_API.HANDLE_EXCEPTIONS
456: (l_api_name,

Line 454: WHEN OKC_API.G_EXCEPTION_ERROR THEN

450: raise OKC_API.G_EXCEPTION_ERROR;
451: END IF;
452: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
453: EXCEPTION
454: WHEN OKC_API.G_EXCEPTION_ERROR THEN
455: x_return_status := OKC_API.HANDLE_EXCEPTIONS
456: (l_api_name,
457: G_PKG_NAME,
458: 'OKC_API.G_RET_STS_ERROR',

Line 455: x_return_status := OKC_API.HANDLE_EXCEPTIONS

451: END IF;
452: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
453: EXCEPTION
454: WHEN OKC_API.G_EXCEPTION_ERROR THEN
455: x_return_status := OKC_API.HANDLE_EXCEPTIONS
456: (l_api_name,
457: G_PKG_NAME,
458: 'OKC_API.G_RET_STS_ERROR',
459: x_msg_count,

Line 458: 'OKC_API.G_RET_STS_ERROR',

454: WHEN OKC_API.G_EXCEPTION_ERROR THEN
455: x_return_status := OKC_API.HANDLE_EXCEPTIONS
456: (l_api_name,
457: G_PKG_NAME,
458: 'OKC_API.G_RET_STS_ERROR',
459: x_msg_count,
460: x_msg_data,
461: '_PUB');
462: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

Line 462: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

458: 'OKC_API.G_RET_STS_ERROR',
459: x_msg_count,
460: x_msg_data,
461: '_PUB');
462: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
463: x_return_status := OKC_API.HANDLE_EXCEPTIONS
464: (l_api_name,
465: G_PKG_NAME,
466: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 463: x_return_status := OKC_API.HANDLE_EXCEPTIONS

459: x_msg_count,
460: x_msg_data,
461: '_PUB');
462: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
463: x_return_status := OKC_API.HANDLE_EXCEPTIONS
464: (l_api_name,
465: G_PKG_NAME,
466: 'OKC_API.G_RET_STS_UNEXP_ERROR',
467: x_msg_count,

Line 466: 'OKC_API.G_RET_STS_UNEXP_ERROR',

462: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
463: x_return_status := OKC_API.HANDLE_EXCEPTIONS
464: (l_api_name,
465: G_PKG_NAME,
466: 'OKC_API.G_RET_STS_UNEXP_ERROR',
467: x_msg_count,
468: x_msg_data,
469: '_PUB');
470: WHEN OTHERS THEN

Line 471: x_return_status := OKC_API.HANDLE_EXCEPTIONS

467: x_msg_count,
468: x_msg_data,
469: '_PUB');
470: WHEN OTHERS THEN
471: x_return_status := OKC_API.HANDLE_EXCEPTIONS
472: (l_api_name,
473: G_PKG_NAME,
474: 'OTHERS',
475: x_msg_count,

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

486: x_msg_data OUT NOCOPY VARCHAR2,
487: p_saev_tbl IN saev_tbl_type,
488: x_saev_tbl OUT NOCOPY saev_tbl_type) IS
489: i NUMBER := 0;
490: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
491:
492: BEGIN
493: x_return_status := OKC_API.G_RET_STS_SUCCESS;
494: IF p_saev_tbl.COUNT > 0 THEN

Line 493: x_return_status := OKC_API.G_RET_STS_SUCCESS;

489: i NUMBER := 0;
490: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
491:
492: BEGIN
493: x_return_status := OKC_API.G_RET_STS_SUCCESS;
494: IF p_saev_tbl.COUNT > 0 THEN
495: i := p_saev_tbl.FIRST;
496: LOOP
497: update_std_article(

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

501: x_msg_count => x_msg_count,
502: x_msg_data => x_msg_data,
503: p_saev_rec => p_saev_tbl(i),
504: x_saev_rec => x_saev_tbl(i));
505: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
506: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
507: x_return_status := l_return_status;
508: raise G_EXCEPTION_HALT_PROCESSING;
509: ELSE

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

502: x_msg_data => x_msg_data,
503: p_saev_rec => p_saev_tbl(i),
504: x_saev_rec => x_saev_tbl(i));
505: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
506: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
507: x_return_status := l_return_status;
508: raise G_EXCEPTION_HALT_PROCESSING;
509: ELSE
510: x_return_status := l_return_status;

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

517: EXCEPTION
518: WHEN G_EXCEPTION_HALT_PROCESSING THEN
519: NULL;
520: WHEN OTHERS THEN
521: OKC_API.set_message(p_app_name => g_app_name,
522: p_msg_name => g_unexpected_error,
523: p_token1 => g_sqlcode_token,
524: p_token1_value => sqlcode,
525: p_token2 => g_sqlerrm_token,

Line 527: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

523: p_token1 => g_sqlcode_token,
524: p_token1_value => sqlcode,
525: p_token2 => g_sqlerrm_token,
526: p_token2_value => sqlerrm);
527: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
528: END update_std_article;
529:
530:
531:

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

535: x_return_status OUT NOCOPY VARCHAR2,
536: x_msg_count OUT NOCOPY NUMBER,
537: x_msg_data OUT NOCOPY VARCHAR2,
538: p_saev_rec IN saev_rec_type) IS
539: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
540: l_api_name CONSTANT VARCHAR2(30) := 'DELETE_STD_ARTICLE';
541: l_saev_rec saev_rec_type := p_saev_rec;
542: BEGIN
543: l_return_status := OKC_API.START_ACTIVITY(l_api_name,

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

539: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
540: l_api_name CONSTANT VARCHAR2(30) := 'DELETE_STD_ARTICLE';
541: l_saev_rec saev_rec_type := p_saev_rec;
542: BEGIN
543: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
544: p_init_msg_list,
545: '_PUB',
546: x_return_status);
547: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

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

543: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
544: p_init_msg_list,
545: '_PUB',
546: x_return_status);
547: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
548: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
549: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
550: raise OKC_API.G_EXCEPTION_ERROR;
551: END IF;

Line 548: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

544: p_init_msg_list,
545: '_PUB',
546: x_return_status);
547: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
548: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
549: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
550: raise OKC_API.G_EXCEPTION_ERROR;
551: END IF;
552: -- Call user hook for BEFORE

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

545: '_PUB',
546: x_return_status);
547: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
548: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
549: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
550: raise OKC_API.G_EXCEPTION_ERROR;
551: END IF;
552: -- Call user hook for BEFORE
553: g_saev_rec := l_saev_rec;

Line 550: raise OKC_API.G_EXCEPTION_ERROR;

546: x_return_status);
547: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
548: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
549: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
550: raise OKC_API.G_EXCEPTION_ERROR;
551: END IF;
552: -- Call user hook for BEFORE
553: g_saev_rec := l_saev_rec;
554: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');

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

551: END IF;
552: -- Call user hook for BEFORE
553: g_saev_rec := l_saev_rec;
554: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
555: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
556: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
557: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
558: raise OKC_API.G_EXCEPTION_ERROR;
559: END IF;

Line 556: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

552: -- Call user hook for BEFORE
553: g_saev_rec := l_saev_rec;
554: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
555: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
556: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
557: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
558: raise OKC_API.G_EXCEPTION_ERROR;
559: END IF;
560: OKC_STD_ARTICLE_PVT.delete_std_article(

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

553: g_saev_rec := l_saev_rec;
554: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
555: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
556: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
557: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
558: raise OKC_API.G_EXCEPTION_ERROR;
559: END IF;
560: OKC_STD_ARTICLE_PVT.delete_std_article(
561: p_api_version => p_api_version,

Line 558: raise OKC_API.G_EXCEPTION_ERROR;

554: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
555: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
556: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
557: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
558: raise OKC_API.G_EXCEPTION_ERROR;
559: END IF;
560: OKC_STD_ARTICLE_PVT.delete_std_article(
561: p_api_version => p_api_version,
562: p_init_msg_list => p_init_msg_list,

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

564: x_msg_count => x_msg_count,
565: x_msg_data => x_msg_data,
566: p_saev_rec => l_saev_rec);
567:
568: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
569: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
570: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
571: raise OKC_API.G_EXCEPTION_ERROR;
572: END IF;

Line 569: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

565: x_msg_data => x_msg_data,
566: p_saev_rec => l_saev_rec);
567:
568: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
569: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
570: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
571: raise OKC_API.G_EXCEPTION_ERROR;
572: END IF;
573:

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

566: p_saev_rec => l_saev_rec);
567:
568: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
569: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
570: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
571: raise OKC_API.G_EXCEPTION_ERROR;
572: END IF;
573:
574: -- Call user hook for AFTER

Line 571: raise OKC_API.G_EXCEPTION_ERROR;

567:
568: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
569: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
570: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
571: raise OKC_API.G_EXCEPTION_ERROR;
572: END IF;
573:
574: -- Call user hook for AFTER
575: g_saev_rec := l_saev_rec;

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

573:
574: -- Call user hook for AFTER
575: g_saev_rec := l_saev_rec;
576: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
577: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
578: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
579: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
580: raise OKC_API.G_EXCEPTION_ERROR;
581: END IF;

Line 578: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

574: -- Call user hook for AFTER
575: g_saev_rec := l_saev_rec;
576: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
577: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
578: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
579: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
580: raise OKC_API.G_EXCEPTION_ERROR;
581: END IF;
582: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

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

575: g_saev_rec := l_saev_rec;
576: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
577: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
578: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
579: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
580: raise OKC_API.G_EXCEPTION_ERROR;
581: END IF;
582: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
583: EXCEPTION

Line 580: raise OKC_API.G_EXCEPTION_ERROR;

576: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
577: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
578: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
579: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
580: raise OKC_API.G_EXCEPTION_ERROR;
581: END IF;
582: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
583: EXCEPTION
584: WHEN OKC_API.G_EXCEPTION_ERROR THEN

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

578: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
579: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
580: raise OKC_API.G_EXCEPTION_ERROR;
581: END IF;
582: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
583: EXCEPTION
584: WHEN OKC_API.G_EXCEPTION_ERROR THEN
585: x_return_status := OKC_API.HANDLE_EXCEPTIONS
586: (l_api_name,

Line 584: WHEN OKC_API.G_EXCEPTION_ERROR THEN

580: raise OKC_API.G_EXCEPTION_ERROR;
581: END IF;
582: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
583: EXCEPTION
584: WHEN OKC_API.G_EXCEPTION_ERROR THEN
585: x_return_status := OKC_API.HANDLE_EXCEPTIONS
586: (l_api_name,
587: G_PKG_NAME,
588: 'OKC_API.G_RET_STS_ERROR',

Line 585: x_return_status := OKC_API.HANDLE_EXCEPTIONS

581: END IF;
582: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
583: EXCEPTION
584: WHEN OKC_API.G_EXCEPTION_ERROR THEN
585: x_return_status := OKC_API.HANDLE_EXCEPTIONS
586: (l_api_name,
587: G_PKG_NAME,
588: 'OKC_API.G_RET_STS_ERROR',
589: x_msg_count,

Line 588: 'OKC_API.G_RET_STS_ERROR',

584: WHEN OKC_API.G_EXCEPTION_ERROR THEN
585: x_return_status := OKC_API.HANDLE_EXCEPTIONS
586: (l_api_name,
587: G_PKG_NAME,
588: 'OKC_API.G_RET_STS_ERROR',
589: x_msg_count,
590: x_msg_data,
591: '_PUB');
592: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

Line 592: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

588: 'OKC_API.G_RET_STS_ERROR',
589: x_msg_count,
590: x_msg_data,
591: '_PUB');
592: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
593: x_return_status := OKC_API.HANDLE_EXCEPTIONS
594: (l_api_name,
595: G_PKG_NAME,
596: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 593: x_return_status := OKC_API.HANDLE_EXCEPTIONS

589: x_msg_count,
590: x_msg_data,
591: '_PUB');
592: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
593: x_return_status := OKC_API.HANDLE_EXCEPTIONS
594: (l_api_name,
595: G_PKG_NAME,
596: 'OKC_API.G_RET_STS_UNEXP_ERROR',
597: x_msg_count,

Line 596: 'OKC_API.G_RET_STS_UNEXP_ERROR',

592: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
593: x_return_status := OKC_API.HANDLE_EXCEPTIONS
594: (l_api_name,
595: G_PKG_NAME,
596: 'OKC_API.G_RET_STS_UNEXP_ERROR',
597: x_msg_count,
598: x_msg_data,
599: '_PUB');
600: WHEN OTHERS THEN

Line 601: x_return_status := OKC_API.HANDLE_EXCEPTIONS

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

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

614: x_msg_count OUT NOCOPY NUMBER,
615: x_msg_data OUT NOCOPY VARCHAR2,
616: p_saev_tbl IN saev_tbl_type) IS
617: i NUMBER := 0;
618: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
619:
620: BEGIN
621: x_return_status := OKC_API.G_RET_STS_SUCCESS;
622: IF p_saev_tbl.COUNT > 0 THEN

Line 621: x_return_status := OKC_API.G_RET_STS_SUCCESS;

617: i NUMBER := 0;
618: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
619:
620: BEGIN
621: x_return_status := OKC_API.G_RET_STS_SUCCESS;
622: IF p_saev_tbl.COUNT > 0 THEN
623: i := p_saev_tbl.FIRST;
624: LOOP
625: delete_std_article(

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

628: x_return_status => l_return_status,
629: x_msg_count => x_msg_count,
630: x_msg_data => x_msg_data,
631: p_saev_rec => p_saev_tbl(i));
632: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
633: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
634: x_return_status := l_return_status;
635: raise G_EXCEPTION_HALT_PROCESSING;
636: ELSE

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

629: x_msg_count => x_msg_count,
630: x_msg_data => x_msg_data,
631: p_saev_rec => p_saev_tbl(i));
632: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
633: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
634: x_return_status := l_return_status;
635: raise G_EXCEPTION_HALT_PROCESSING;
636: ELSE
637: x_return_status := l_return_status;

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

644: EXCEPTION
645: WHEN G_EXCEPTION_HALT_PROCESSING THEN
646: NULL;
647: WHEN OTHERS THEN
648: OKC_API.set_message(p_app_name => g_app_name,
649: p_msg_name => g_unexpected_error,
650: p_token1 => g_sqlcode_token,
651: p_token1_value => sqlcode,
652: p_token2 => g_sqlerrm_token,

Line 654: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

650: p_token1 => g_sqlcode_token,
651: p_token1_value => sqlcode,
652: p_token2 => g_sqlerrm_token,
653: p_token2_value => sqlerrm);
654: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
655: END delete_std_article;
656:
657:
658: PROCEDURE validate_std_article(

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

682: x_msg_count OUT NOCOPY NUMBER,
683: x_msg_data OUT NOCOPY VARCHAR2,
684: p_saev_tbl IN saev_tbl_type) IS
685: i NUMBER := 0;
686: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
687:
688: BEGIN
689: x_return_status := OKC_API.G_RET_STS_SUCCESS;
690: IF p_saev_tbl.COUNT > 0 THEN

Line 689: x_return_status := OKC_API.G_RET_STS_SUCCESS;

685: i NUMBER := 0;
686: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
687:
688: BEGIN
689: x_return_status := OKC_API.G_RET_STS_SUCCESS;
690: IF p_saev_tbl.COUNT > 0 THEN
691: i := p_saev_tbl.FIRST;
692: LOOP
693: validate_std_article(

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

696: x_return_status => l_return_status,
697: x_msg_count => x_msg_count,
698: x_msg_data => x_msg_data,
699: p_saev_rec => p_saev_tbl(i));
700: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
701: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
702: x_return_status := l_return_status;
703: raise G_EXCEPTION_HALT_PROCESSING;
704: ELSE

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

697: x_msg_count => x_msg_count,
698: x_msg_data => x_msg_data,
699: p_saev_rec => p_saev_tbl(i));
700: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
701: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
702: x_return_status := l_return_status;
703: raise G_EXCEPTION_HALT_PROCESSING;
704: ELSE
705: x_return_status := l_return_status;

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

712: EXCEPTION
713: WHEN G_EXCEPTION_HALT_PROCESSING THEN
714: NULL;
715: WHEN OTHERS THEN
716: OKC_API.set_message(p_app_name => g_app_name,
717: p_msg_name => g_unexpected_error,
718: p_token1 => g_sqlcode_token,
719: p_token1_value => sqlcode,
720: p_token2 => g_sqlerrm_token,

Line 722: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

718: p_token1 => g_sqlcode_token,
719: p_token1_value => sqlcode,
720: p_token2 => g_sqlerrm_token,
721: p_token2_value => sqlerrm);
722: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
723: END validate_std_article;
724:
725:
726: PROCEDURE lock_std_article(

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

749: x_msg_count OUT NOCOPY NUMBER,
750: x_msg_data OUT NOCOPY VARCHAR2,
751: p_saev_tbl IN saev_tbl_type) IS
752: i NUMBER := 0;
753: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
754:
755: BEGIN
756: x_return_status := OKC_API.G_RET_STS_SUCCESS;
757: IF p_saev_tbl.COUNT > 0 THEN

Line 756: x_return_status := OKC_API.G_RET_STS_SUCCESS;

752: i NUMBER := 0;
753: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
754:
755: BEGIN
756: x_return_status := OKC_API.G_RET_STS_SUCCESS;
757: IF p_saev_tbl.COUNT > 0 THEN
758: i := p_saev_tbl.FIRST;
759: LOOP
760: lock_std_article(

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

763: x_return_status => l_return_status,
764: x_msg_count => x_msg_count,
765: x_msg_data => x_msg_data,
766: p_saev_rec => p_saev_tbl(i));
767: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
768: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
769: x_return_status := l_return_status;
770: raise G_EXCEPTION_HALT_PROCESSING;
771: ELSE

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

764: x_msg_count => x_msg_count,
765: x_msg_data => x_msg_data,
766: p_saev_rec => p_saev_tbl(i));
767: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
768: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
769: x_return_status := l_return_status;
770: raise G_EXCEPTION_HALT_PROCESSING;
771: ELSE
772: x_return_status := l_return_status;

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

779: EXCEPTION
780: WHEN G_EXCEPTION_HALT_PROCESSING THEN
781: NULL;
782: WHEN OTHERS THEN
783: OKC_API.set_message(p_app_name => g_app_name,
784: p_msg_name => g_unexpected_error,
785: p_token1 => g_sqlcode_token,
786: p_token1_value => sqlcode,
787: p_token2 => g_sqlerrm_token,

Line 789: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

785: p_token1 => g_sqlcode_token,
786: p_token1_value => sqlcode,
787: p_token2 => g_sqlerrm_token,
788: p_token2_value => sqlerrm);
789: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
790: END lock_std_article;
791:
792:
793: PROCEDURE validate_name(

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

815: x_msg_data OUT NOCOPY VARCHAR2,
816: p_saev_tbl IN saev_tbl_type) IS
817:
818: i NUMBER := 0;
819: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
820:
821: BEGIN
822: x_return_status := OKC_API.G_RET_STS_SUCCESS;
823: IF p_saev_tbl.COUNT > 0 THEN

Line 822: x_return_status := OKC_API.G_RET_STS_SUCCESS;

818: i NUMBER := 0;
819: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
820:
821: BEGIN
822: x_return_status := OKC_API.G_RET_STS_SUCCESS;
823: IF p_saev_tbl.COUNT > 0 THEN
824: i := p_saev_tbl.FIRST;
825: LOOP
826: Validate_Name(p_api_version => p_api_version,

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

829: x_msg_count => x_msg_count,
830: x_msg_data => x_msg_data,
831: p_saev_rec => p_saev_tbl(i));
832:
833: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
834: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
835: x_return_status := l_return_status;
836: raise G_EXCEPTION_HALT_PROCESSING;
837: ELSE

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

830: x_msg_data => x_msg_data,
831: p_saev_rec => p_saev_tbl(i));
832:
833: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
834: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
835: x_return_status := l_return_status;
836: raise G_EXCEPTION_HALT_PROCESSING;
837: ELSE
838: x_return_status := l_return_status;

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

845: EXCEPTION
846: WHEN G_EXCEPTION_HALT_PROCESSING THEN
847: NULL;
848: WHEN OTHERS THEN
849: OKC_API.set_message(p_app_name => g_app_name,
850: p_msg_name => g_unexpected_error,
851: p_token1 => g_sqlcode_token,
852: p_token1_value => sqlcode,
853: p_token2 => g_sqlerrm_token,

Line 855: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

851: p_token1 => g_sqlcode_token,
852: p_token1_value => sqlcode,
853: p_token2 => g_sqlerrm_token,
854: p_token2_value => sqlerrm);
855: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
856: End Validate_name;
857:
858: PROCEDURE validate_no_k_attached(
859: p_saev_rec IN saev_rec_type,

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

869: p_saev_tbl IN saev_tbl_type,
870: x_return_status OUT NOCOPY VARCHAR2) IS
871:
872: i NUMBER := 0;
873: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
874:
875: BEGIN
876: x_return_status := OKC_API.G_RET_STS_SUCCESS;
877: IF p_saev_tbl.COUNT > 0 THEN

Line 876: x_return_status := OKC_API.G_RET_STS_SUCCESS;

872: i NUMBER := 0;
873: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
874:
875: BEGIN
876: x_return_status := OKC_API.G_RET_STS_SUCCESS;
877: IF p_saev_tbl.COUNT > 0 THEN
878: i := p_saev_tbl.FIRST;
879: LOOP
880: Validate_no_k_attached(

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

880: Validate_no_k_attached(
881: x_return_status => l_return_status,
882: p_saev_rec => p_saev_tbl(i));
883:
884: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
885: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
886: x_return_status := l_return_status;
887: raise G_EXCEPTION_HALT_PROCESSING;
888: ELSE

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

881: x_return_status => l_return_status,
882: p_saev_rec => p_saev_tbl(i));
883:
884: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
885: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
886: x_return_status := l_return_status;
887: raise G_EXCEPTION_HALT_PROCESSING;
888: ELSE
889: x_return_status := l_return_status;

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

896: EXCEPTION
897: WHEN G_EXCEPTION_HALT_PROCESSING THEN
898: NULL;
899: WHEN OTHERS THEN
900: OKC_API.set_message(p_app_name => g_app_name,
901: p_msg_name => g_unexpected_error,
902: p_token1 => g_sqlcode_token,
903: p_token1_value => sqlcode,
904: p_token2 => g_sqlerrm_token,

Line 906: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

902: p_token1 => g_sqlcode_token,
903: p_token1_value => sqlcode,
904: p_token2 => g_sqlerrm_token,
905: p_token2_value => sqlerrm);
906: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
907:
908: End Validate_no_k_attached;
909:
910: PROCEDURE Create_std_art_version(

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

914: x_msg_count OUT NOCOPY NUMBER,
915: x_msg_data OUT NOCOPY VARCHAR2,
916: p_savv_rec IN savv_rec_type,
917: x_savv_rec OUT NOCOPY savv_rec_type) IS
918: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
919: l_api_name CONSTANT VARCHAR2(30) := 'CREATE_STD_ART_VERSION';
920: l_savv_rec savv_rec_type := p_savv_rec;
921: BEGIN
922: l_return_status := OKC_API.START_ACTIVITY(l_api_name,

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

918: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
919: l_api_name CONSTANT VARCHAR2(30) := 'CREATE_STD_ART_VERSION';
920: l_savv_rec savv_rec_type := p_savv_rec;
921: BEGIN
922: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
923: p_init_msg_list,
924: '_PUB',
925: x_return_status);
926: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

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

922: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
923: p_init_msg_list,
924: '_PUB',
925: x_return_status);
926: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
927: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
928: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
929: raise OKC_API.G_EXCEPTION_ERROR;
930: END IF;

Line 927: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

923: p_init_msg_list,
924: '_PUB',
925: x_return_status);
926: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
927: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
928: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
929: raise OKC_API.G_EXCEPTION_ERROR;
930: END IF;
931: -- Call user hook for BEFORE

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

924: '_PUB',
925: x_return_status);
926: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
927: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
928: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
929: raise OKC_API.G_EXCEPTION_ERROR;
930: END IF;
931: -- Call user hook for BEFORE
932: g_savv_rec := l_savv_rec;

Line 929: raise OKC_API.G_EXCEPTION_ERROR;

925: x_return_status);
926: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
927: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
928: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
929: raise OKC_API.G_EXCEPTION_ERROR;
930: END IF;
931: -- Call user hook for BEFORE
932: g_savv_rec := l_savv_rec;
933: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');

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

930: END IF;
931: -- Call user hook for BEFORE
932: g_savv_rec := l_savv_rec;
933: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
934: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
935: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
936: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
937: raise OKC_API.G_EXCEPTION_ERROR;
938: END IF;

Line 935: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

931: -- Call user hook for BEFORE
932: g_savv_rec := l_savv_rec;
933: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
934: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
935: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
936: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
937: raise OKC_API.G_EXCEPTION_ERROR;
938: END IF;
939: l_savv_rec := migrate_savv(l_savv_rec, g_savv_rec);

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

932: g_savv_rec := l_savv_rec;
933: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
934: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
935: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
936: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
937: raise OKC_API.G_EXCEPTION_ERROR;
938: END IF;
939: l_savv_rec := migrate_savv(l_savv_rec, g_savv_rec);
940:

Line 937: raise OKC_API.G_EXCEPTION_ERROR;

933: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
934: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
935: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
936: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
937: raise OKC_API.G_EXCEPTION_ERROR;
938: END IF;
939: l_savv_rec := migrate_savv(l_savv_rec, g_savv_rec);
940:
941: OKC_STD_ARTICLE_PVT.create_std_art_version(

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

946: x_msg_data => x_msg_data,
947: p_savv_rec => l_savv_rec,
948: x_savv_rec => x_savv_rec);
949:
950: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
951: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
952: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
953: raise OKC_API.G_EXCEPTION_ERROR;
954: END IF;

Line 951: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

947: p_savv_rec => l_savv_rec,
948: x_savv_rec => x_savv_rec);
949:
950: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
951: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
952: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
953: raise OKC_API.G_EXCEPTION_ERROR;
954: END IF;
955:

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

948: x_savv_rec => x_savv_rec);
949:
950: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
951: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
952: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
953: raise OKC_API.G_EXCEPTION_ERROR;
954: END IF;
955:
956: -- Call user hook for AFTER

Line 953: raise OKC_API.G_EXCEPTION_ERROR;

949:
950: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
951: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
952: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
953: raise OKC_API.G_EXCEPTION_ERROR;
954: END IF;
955:
956: -- Call user hook for AFTER
957: g_savv_rec := x_savv_rec;

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

955:
956: -- Call user hook for AFTER
957: g_savv_rec := x_savv_rec;
958: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
959: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
960: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
961: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
962: raise OKC_API.G_EXCEPTION_ERROR;
963: END IF;

Line 960: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

956: -- Call user hook for AFTER
957: g_savv_rec := x_savv_rec;
958: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
959: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
960: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
961: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
962: raise OKC_API.G_EXCEPTION_ERROR;
963: END IF;
964: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

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

957: g_savv_rec := x_savv_rec;
958: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
959: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
960: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
961: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
962: raise OKC_API.G_EXCEPTION_ERROR;
963: END IF;
964: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
965: EXCEPTION

Line 962: raise OKC_API.G_EXCEPTION_ERROR;

958: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
959: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
960: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
961: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
962: raise OKC_API.G_EXCEPTION_ERROR;
963: END IF;
964: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
965: EXCEPTION
966: WHEN OKC_API.G_EXCEPTION_ERROR THEN

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

960: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
961: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
962: raise OKC_API.G_EXCEPTION_ERROR;
963: END IF;
964: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
965: EXCEPTION
966: WHEN OKC_API.G_EXCEPTION_ERROR THEN
967: x_return_status := OKC_API.HANDLE_EXCEPTIONS
968: (l_api_name,

Line 966: WHEN OKC_API.G_EXCEPTION_ERROR THEN

962: raise OKC_API.G_EXCEPTION_ERROR;
963: END IF;
964: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
965: EXCEPTION
966: WHEN OKC_API.G_EXCEPTION_ERROR THEN
967: x_return_status := OKC_API.HANDLE_EXCEPTIONS
968: (l_api_name,
969: G_PKG_NAME,
970: 'OKC_API.G_RET_STS_ERROR',

Line 967: x_return_status := OKC_API.HANDLE_EXCEPTIONS

963: END IF;
964: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
965: EXCEPTION
966: WHEN OKC_API.G_EXCEPTION_ERROR THEN
967: x_return_status := OKC_API.HANDLE_EXCEPTIONS
968: (l_api_name,
969: G_PKG_NAME,
970: 'OKC_API.G_RET_STS_ERROR',
971: x_msg_count,

Line 970: 'OKC_API.G_RET_STS_ERROR',

966: WHEN OKC_API.G_EXCEPTION_ERROR THEN
967: x_return_status := OKC_API.HANDLE_EXCEPTIONS
968: (l_api_name,
969: G_PKG_NAME,
970: 'OKC_API.G_RET_STS_ERROR',
971: x_msg_count,
972: x_msg_data,
973: '_PUB');
974: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

Line 974: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

970: 'OKC_API.G_RET_STS_ERROR',
971: x_msg_count,
972: x_msg_data,
973: '_PUB');
974: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
975: x_return_status := OKC_API.HANDLE_EXCEPTIONS
976: (l_api_name,
977: G_PKG_NAME,
978: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 975: x_return_status := OKC_API.HANDLE_EXCEPTIONS

971: x_msg_count,
972: x_msg_data,
973: '_PUB');
974: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
975: x_return_status := OKC_API.HANDLE_EXCEPTIONS
976: (l_api_name,
977: G_PKG_NAME,
978: 'OKC_API.G_RET_STS_UNEXP_ERROR',
979: x_msg_count,

Line 978: 'OKC_API.G_RET_STS_UNEXP_ERROR',

974: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
975: x_return_status := OKC_API.HANDLE_EXCEPTIONS
976: (l_api_name,
977: G_PKG_NAME,
978: 'OKC_API.G_RET_STS_UNEXP_ERROR',
979: x_msg_count,
980: x_msg_data,
981: '_PUB');
982: WHEN OTHERS THEN

Line 983: x_return_status := OKC_API.HANDLE_EXCEPTIONS

979: x_msg_count,
980: x_msg_data,
981: '_PUB');
982: WHEN OTHERS THEN
983: x_return_status := OKC_API.HANDLE_EXCEPTIONS
984: (l_api_name,
985: G_PKG_NAME,
986: 'OTHERS',
987: x_msg_count,

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

998: x_msg_data OUT NOCOPY VARCHAR2,
999: p_savv_tbl IN savv_tbl_type,
1000: x_savv_tbl OUT NOCOPY savv_tbl_type) IS
1001: i NUMBER := 0;
1002: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1003:
1004: BEGIN
1005: x_return_status := OKC_API.G_RET_STS_SUCCESS;
1006: IF p_savv_tbl.COUNT > 0 THEN

Line 1005: x_return_status := OKC_API.G_RET_STS_SUCCESS;

1001: i NUMBER := 0;
1002: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1003:
1004: BEGIN
1005: x_return_status := OKC_API.G_RET_STS_SUCCESS;
1006: IF p_savv_tbl.COUNT > 0 THEN
1007: i := p_savv_tbl.FIRST;
1008: LOOP
1009: create_std_art_version(

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

1013: x_msg_count => x_msg_count,
1014: x_msg_data => x_msg_data,
1015: p_savv_rec => p_savv_tbl(i),
1016: x_savv_rec => x_savv_tbl(i));
1017: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1018: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1019: x_return_status := l_return_status;
1020: raise G_EXCEPTION_HALT_PROCESSING;
1021: ELSE

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

1014: x_msg_data => x_msg_data,
1015: p_savv_rec => p_savv_tbl(i),
1016: x_savv_rec => x_savv_tbl(i));
1017: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1018: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1019: x_return_status := l_return_status;
1020: raise G_EXCEPTION_HALT_PROCESSING;
1021: ELSE
1022: x_return_status := l_return_status;

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

1029: EXCEPTION
1030: WHEN G_EXCEPTION_HALT_PROCESSING THEN
1031: NULL;
1032: WHEN OTHERS THEN
1033: OKC_API.set_message(p_app_name => g_app_name,
1034: p_msg_name => g_unexpected_error,
1035: p_token1 => g_sqlcode_token,
1036: p_token1_value => sqlcode,
1037: p_token2 => g_sqlerrm_token,

Line 1039: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

1035: p_token1 => g_sqlcode_token,
1036: p_token1_value => sqlcode,
1037: p_token2 => g_sqlerrm_token,
1038: p_token2_value => sqlerrm);
1039: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
1040: END Create_std_art_version;
1041:
1042:
1043:

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

1048: x_msg_count OUT NOCOPY NUMBER,
1049: x_msg_data OUT NOCOPY VARCHAR2,
1050: p_savv_rec IN savv_rec_type,
1051: x_savv_rec OUT NOCOPY savv_rec_type) IS
1052: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1053: l_api_name CONSTANT VARCHAR2(30) := 'UPDATE_STD_ART_VERSION';
1054: l_savv_rec savv_rec_type := p_savv_rec;
1055: BEGIN
1056: l_return_status := OKC_API.START_ACTIVITY(l_api_name,

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

1052: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1053: l_api_name CONSTANT VARCHAR2(30) := 'UPDATE_STD_ART_VERSION';
1054: l_savv_rec savv_rec_type := p_savv_rec;
1055: BEGIN
1056: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
1057: p_init_msg_list,
1058: '_PUB',
1059: x_return_status);
1060: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

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

1056: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
1057: p_init_msg_list,
1058: '_PUB',
1059: x_return_status);
1060: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1061: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1062: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1063: raise OKC_API.G_EXCEPTION_ERROR;
1064: END IF;

Line 1061: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1057: p_init_msg_list,
1058: '_PUB',
1059: x_return_status);
1060: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1061: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1062: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1063: raise OKC_API.G_EXCEPTION_ERROR;
1064: END IF;
1065: -- Call user hook for BEFORE

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

1058: '_PUB',
1059: x_return_status);
1060: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1061: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1062: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1063: raise OKC_API.G_EXCEPTION_ERROR;
1064: END IF;
1065: -- Call user hook for BEFORE
1066: g_savv_rec := l_savv_rec;

Line 1063: raise OKC_API.G_EXCEPTION_ERROR;

1059: x_return_status);
1060: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1061: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1062: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1063: raise OKC_API.G_EXCEPTION_ERROR;
1064: END IF;
1065: -- Call user hook for BEFORE
1066: g_savv_rec := l_savv_rec;
1067: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');

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

1064: END IF;
1065: -- Call user hook for BEFORE
1066: g_savv_rec := l_savv_rec;
1067: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
1068: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1069: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1070: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1071: raise OKC_API.G_EXCEPTION_ERROR;
1072: END IF;

Line 1069: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1065: -- Call user hook for BEFORE
1066: g_savv_rec := l_savv_rec;
1067: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
1068: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1069: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1070: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1071: raise OKC_API.G_EXCEPTION_ERROR;
1072: END IF;
1073: l_savv_rec := migrate_savv(l_savv_rec, g_savv_rec);

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

1066: g_savv_rec := l_savv_rec;
1067: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
1068: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1069: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1070: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1071: raise OKC_API.G_EXCEPTION_ERROR;
1072: END IF;
1073: l_savv_rec := migrate_savv(l_savv_rec, g_savv_rec);
1074:

Line 1071: raise OKC_API.G_EXCEPTION_ERROR;

1067: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
1068: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1069: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1070: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1071: raise OKC_API.G_EXCEPTION_ERROR;
1072: END IF;
1073: l_savv_rec := migrate_savv(l_savv_rec, g_savv_rec);
1074:
1075: OKC_STD_ARTICLE_PVT.update_std_art_version(

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

1080: x_msg_data => x_msg_data,
1081: p_savv_rec => l_savv_rec,
1082: x_savv_rec => x_savv_rec);
1083:
1084: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1085: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1086: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1087: raise OKC_API.G_EXCEPTION_ERROR;
1088: END IF;

Line 1085: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1081: p_savv_rec => l_savv_rec,
1082: x_savv_rec => x_savv_rec);
1083:
1084: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1085: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1086: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1087: raise OKC_API.G_EXCEPTION_ERROR;
1088: END IF;
1089:

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

1082: x_savv_rec => x_savv_rec);
1083:
1084: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1085: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1086: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1087: raise OKC_API.G_EXCEPTION_ERROR;
1088: END IF;
1089:
1090: -- Call user hook for AFTER

Line 1087: raise OKC_API.G_EXCEPTION_ERROR;

1083:
1084: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1085: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1086: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1087: raise OKC_API.G_EXCEPTION_ERROR;
1088: END IF;
1089:
1090: -- Call user hook for AFTER
1091: g_savv_rec := x_savv_rec;

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

1089:
1090: -- Call user hook for AFTER
1091: g_savv_rec := x_savv_rec;
1092: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
1093: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1094: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1095: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1096: raise OKC_API.G_EXCEPTION_ERROR;
1097: END IF;

Line 1094: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1090: -- Call user hook for AFTER
1091: g_savv_rec := x_savv_rec;
1092: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
1093: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1094: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1095: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1096: raise OKC_API.G_EXCEPTION_ERROR;
1097: END IF;
1098: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

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

1091: g_savv_rec := x_savv_rec;
1092: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
1093: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1094: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1095: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1096: raise OKC_API.G_EXCEPTION_ERROR;
1097: END IF;
1098: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1099: EXCEPTION

Line 1096: raise OKC_API.G_EXCEPTION_ERROR;

1092: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
1093: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1094: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1095: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1096: raise OKC_API.G_EXCEPTION_ERROR;
1097: END IF;
1098: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1099: EXCEPTION
1100: WHEN OKC_API.G_EXCEPTION_ERROR THEN

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

1094: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1095: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1096: raise OKC_API.G_EXCEPTION_ERROR;
1097: END IF;
1098: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1099: EXCEPTION
1100: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1101: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1102: (l_api_name,

Line 1100: WHEN OKC_API.G_EXCEPTION_ERROR THEN

1096: raise OKC_API.G_EXCEPTION_ERROR;
1097: END IF;
1098: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1099: EXCEPTION
1100: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1101: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1102: (l_api_name,
1103: G_PKG_NAME,
1104: 'OKC_API.G_RET_STS_ERROR',

Line 1101: x_return_status := OKC_API.HANDLE_EXCEPTIONS

1097: END IF;
1098: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1099: EXCEPTION
1100: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1101: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1102: (l_api_name,
1103: G_PKG_NAME,
1104: 'OKC_API.G_RET_STS_ERROR',
1105: x_msg_count,

Line 1104: 'OKC_API.G_RET_STS_ERROR',

1100: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1101: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1102: (l_api_name,
1103: G_PKG_NAME,
1104: 'OKC_API.G_RET_STS_ERROR',
1105: x_msg_count,
1106: x_msg_data,
1107: '_PUB');
1108: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

Line 1108: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

1104: 'OKC_API.G_RET_STS_ERROR',
1105: x_msg_count,
1106: x_msg_data,
1107: '_PUB');
1108: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1109: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1110: (l_api_name,
1111: G_PKG_NAME,
1112: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 1109: x_return_status := OKC_API.HANDLE_EXCEPTIONS

1105: x_msg_count,
1106: x_msg_data,
1107: '_PUB');
1108: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1109: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1110: (l_api_name,
1111: G_PKG_NAME,
1112: 'OKC_API.G_RET_STS_UNEXP_ERROR',
1113: x_msg_count,

Line 1112: 'OKC_API.G_RET_STS_UNEXP_ERROR',

1108: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1109: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1110: (l_api_name,
1111: G_PKG_NAME,
1112: 'OKC_API.G_RET_STS_UNEXP_ERROR',
1113: x_msg_count,
1114: x_msg_data,
1115: '_PUB');
1116: WHEN OTHERS THEN

Line 1117: x_return_status := OKC_API.HANDLE_EXCEPTIONS

1113: x_msg_count,
1114: x_msg_data,
1115: '_PUB');
1116: WHEN OTHERS THEN
1117: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1118: (l_api_name,
1119: G_PKG_NAME,
1120: 'OTHERS',
1121: x_msg_count,

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

1131: x_msg_data OUT NOCOPY VARCHAR2,
1132: p_savv_tbl IN savv_tbl_type,
1133: x_savv_tbl OUT NOCOPY savv_tbl_type) IS
1134: i NUMBER := 0;
1135: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1136:
1137: BEGIN
1138: x_return_status := OKC_API.G_RET_STS_SUCCESS;
1139: IF p_savv_tbl.COUNT > 0 THEN

Line 1138: x_return_status := OKC_API.G_RET_STS_SUCCESS;

1134: i NUMBER := 0;
1135: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1136:
1137: BEGIN
1138: x_return_status := OKC_API.G_RET_STS_SUCCESS;
1139: IF p_savv_tbl.COUNT > 0 THEN
1140: i := p_savv_tbl.FIRST;
1141: LOOP
1142: update_std_art_version(

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

1146: x_msg_count => x_msg_count,
1147: x_msg_data => x_msg_data,
1148: p_savv_rec => p_savv_tbl(i),
1149: x_savv_rec => x_savv_tbl(i));
1150: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1151: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1152: x_return_status := l_return_status;
1153: raise G_EXCEPTION_HALT_PROCESSING;
1154: ELSE

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

1147: x_msg_data => x_msg_data,
1148: p_savv_rec => p_savv_tbl(i),
1149: x_savv_rec => x_savv_tbl(i));
1150: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1151: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1152: x_return_status := l_return_status;
1153: raise G_EXCEPTION_HALT_PROCESSING;
1154: ELSE
1155: x_return_status := l_return_status;

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

1162: EXCEPTION
1163: WHEN G_EXCEPTION_HALT_PROCESSING THEN
1164: NULL;
1165: WHEN OTHERS THEN
1166: OKC_API.set_message(p_app_name => g_app_name,
1167: p_msg_name => g_unexpected_error,
1168: p_token1 => g_sqlcode_token,
1169: p_token1_value => sqlcode,
1170: p_token2 => g_sqlerrm_token,

Line 1172: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

1168: p_token1 => g_sqlcode_token,
1169: p_token1_value => sqlcode,
1170: p_token2 => g_sqlerrm_token,
1171: p_token2_value => sqlerrm);
1172: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
1173: END update_std_art_version;
1174:
1175:
1176: PROCEDURE lock_std_art_version(

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

1198: x_msg_count OUT NOCOPY NUMBER,
1199: x_msg_data OUT NOCOPY VARCHAR2,
1200: p_savv_tbl IN savv_tbl_type) IS
1201: i NUMBER := 0;
1202: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1203:
1204: BEGIN
1205: x_return_status := OKC_API.G_RET_STS_SUCCESS;
1206: IF p_savv_tbl.COUNT > 0 THEN

Line 1205: x_return_status := OKC_API.G_RET_STS_SUCCESS;

1201: i NUMBER := 0;
1202: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1203:
1204: BEGIN
1205: x_return_status := OKC_API.G_RET_STS_SUCCESS;
1206: IF p_savv_tbl.COUNT > 0 THEN
1207: i := p_savv_tbl.FIRST;
1208: LOOP
1209: lock_std_art_version(

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

1212: x_return_status => l_return_status,
1213: x_msg_count => x_msg_count,
1214: x_msg_data => x_msg_data,
1215: p_savv_rec => p_savv_tbl(i));
1216: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1217: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1218: x_return_status := l_return_status;
1219: raise G_EXCEPTION_HALT_PROCESSING;
1220: ELSE

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

1213: x_msg_count => x_msg_count,
1214: x_msg_data => x_msg_data,
1215: p_savv_rec => p_savv_tbl(i));
1216: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1217: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1218: x_return_status := l_return_status;
1219: raise G_EXCEPTION_HALT_PROCESSING;
1220: ELSE
1221: x_return_status := l_return_status;

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

1228: EXCEPTION
1229: WHEN G_EXCEPTION_HALT_PROCESSING THEN
1230: NULL;
1231: WHEN OTHERS THEN
1232: OKC_API.set_message(p_app_name => g_app_name,
1233: p_msg_name => g_unexpected_error,
1234: p_token1 => g_sqlcode_token,
1235: p_token1_value => sqlcode,
1236: p_token2 => g_sqlerrm_token,

Line 1238: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

1234: p_token1 => g_sqlcode_token,
1235: p_token1_value => sqlcode,
1236: p_token2 => g_sqlerrm_token,
1237: p_token2_value => sqlerrm);
1238: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
1239: END lock_std_art_version;
1240:
1241: PROCEDURE delete_std_art_version(
1242: p_api_version IN NUMBER,

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

1244: x_return_status OUT NOCOPY VARCHAR2,
1245: x_msg_count OUT NOCOPY NUMBER,
1246: x_msg_data OUT NOCOPY VARCHAR2,
1247: p_savv_rec IN savv_rec_type) IS
1248: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1249: l_api_name CONSTANT VARCHAR2(30) := 'DELETE_STD_ART_VERSION';
1250: l_savv_rec savv_rec_type := p_savv_rec;
1251: BEGIN
1252: l_return_status := OKC_API.START_ACTIVITY(l_api_name,

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

1248: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1249: l_api_name CONSTANT VARCHAR2(30) := 'DELETE_STD_ART_VERSION';
1250: l_savv_rec savv_rec_type := p_savv_rec;
1251: BEGIN
1252: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
1253: p_init_msg_list,
1254: '_PUB',
1255: x_return_status);
1256: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

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

1252: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
1253: p_init_msg_list,
1254: '_PUB',
1255: x_return_status);
1256: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1257: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1258: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1259: raise OKC_API.G_EXCEPTION_ERROR;
1260: END IF;

Line 1257: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1253: p_init_msg_list,
1254: '_PUB',
1255: x_return_status);
1256: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1257: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1258: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1259: raise OKC_API.G_EXCEPTION_ERROR;
1260: END IF;
1261: -- Call user hook for BEFORE

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

1254: '_PUB',
1255: x_return_status);
1256: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1257: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1258: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1259: raise OKC_API.G_EXCEPTION_ERROR;
1260: END IF;
1261: -- Call user hook for BEFORE
1262: g_savv_rec := l_savv_rec;

Line 1259: raise OKC_API.G_EXCEPTION_ERROR;

1255: x_return_status);
1256: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1257: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1258: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1259: raise OKC_API.G_EXCEPTION_ERROR;
1260: END IF;
1261: -- Call user hook for BEFORE
1262: g_savv_rec := l_savv_rec;
1263: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');

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

1260: END IF;
1261: -- Call user hook for BEFORE
1262: g_savv_rec := l_savv_rec;
1263: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
1264: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1265: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1266: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1267: raise OKC_API.G_EXCEPTION_ERROR;
1268: END IF;

Line 1265: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1261: -- Call user hook for BEFORE
1262: g_savv_rec := l_savv_rec;
1263: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
1264: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1265: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1266: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1267: raise OKC_API.G_EXCEPTION_ERROR;
1268: END IF;
1269: l_savv_rec := migrate_savv(l_savv_rec, g_savv_rec);

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

1262: g_savv_rec := l_savv_rec;
1263: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
1264: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1265: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1266: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1267: raise OKC_API.G_EXCEPTION_ERROR;
1268: END IF;
1269: l_savv_rec := migrate_savv(l_savv_rec, g_savv_rec);
1270:

Line 1267: raise OKC_API.G_EXCEPTION_ERROR;

1263: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
1264: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1265: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1266: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1267: raise OKC_API.G_EXCEPTION_ERROR;
1268: END IF;
1269: l_savv_rec := migrate_savv(l_savv_rec, g_savv_rec);
1270:
1271: OKC_STD_ARTICLE_PVT.delete_std_art_version(

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

1275: x_msg_count => x_msg_count,
1276: x_msg_data => x_msg_data,
1277: p_savv_rec => l_savv_rec);
1278:
1279: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1280: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1281: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1282: raise OKC_API.G_EXCEPTION_ERROR;
1283: END IF;

Line 1280: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1276: x_msg_data => x_msg_data,
1277: p_savv_rec => l_savv_rec);
1278:
1279: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1280: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1281: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1282: raise OKC_API.G_EXCEPTION_ERROR;
1283: END IF;
1284:

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

1277: p_savv_rec => l_savv_rec);
1278:
1279: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1280: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1281: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1282: raise OKC_API.G_EXCEPTION_ERROR;
1283: END IF;
1284:
1285: -- Call user hook for AFTER

Line 1282: raise OKC_API.G_EXCEPTION_ERROR;

1278:
1279: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1280: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1281: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1282: raise OKC_API.G_EXCEPTION_ERROR;
1283: END IF;
1284:
1285: -- Call user hook for AFTER
1286: g_savv_rec := l_savv_rec;

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

1284:
1285: -- Call user hook for AFTER
1286: g_savv_rec := l_savv_rec;
1287: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
1288: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1289: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1290: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1291: raise OKC_API.G_EXCEPTION_ERROR;
1292: END IF;

Line 1289: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1285: -- Call user hook for AFTER
1286: g_savv_rec := l_savv_rec;
1287: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
1288: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1289: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1290: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1291: raise OKC_API.G_EXCEPTION_ERROR;
1292: END IF;
1293: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

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

1286: g_savv_rec := l_savv_rec;
1287: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
1288: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1289: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1290: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1291: raise OKC_API.G_EXCEPTION_ERROR;
1292: END IF;
1293: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1294: EXCEPTION

Line 1291: raise OKC_API.G_EXCEPTION_ERROR;

1287: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
1288: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1289: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1290: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1291: raise OKC_API.G_EXCEPTION_ERROR;
1292: END IF;
1293: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1294: EXCEPTION
1295: WHEN OKC_API.G_EXCEPTION_ERROR THEN

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

1289: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1290: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1291: raise OKC_API.G_EXCEPTION_ERROR;
1292: END IF;
1293: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1294: EXCEPTION
1295: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1296: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1297: (l_api_name,

Line 1295: WHEN OKC_API.G_EXCEPTION_ERROR THEN

1291: raise OKC_API.G_EXCEPTION_ERROR;
1292: END IF;
1293: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1294: EXCEPTION
1295: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1296: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1297: (l_api_name,
1298: G_PKG_NAME,
1299: 'OKC_API.G_RET_STS_ERROR',

Line 1296: x_return_status := OKC_API.HANDLE_EXCEPTIONS

1292: END IF;
1293: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1294: EXCEPTION
1295: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1296: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1297: (l_api_name,
1298: G_PKG_NAME,
1299: 'OKC_API.G_RET_STS_ERROR',
1300: x_msg_count,

Line 1299: 'OKC_API.G_RET_STS_ERROR',

1295: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1296: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1297: (l_api_name,
1298: G_PKG_NAME,
1299: 'OKC_API.G_RET_STS_ERROR',
1300: x_msg_count,
1301: x_msg_data,
1302: '_PUB');
1303: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

Line 1303: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

1299: 'OKC_API.G_RET_STS_ERROR',
1300: x_msg_count,
1301: x_msg_data,
1302: '_PUB');
1303: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1304: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1305: (l_api_name,
1306: G_PKG_NAME,
1307: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 1304: x_return_status := OKC_API.HANDLE_EXCEPTIONS

1300: x_msg_count,
1301: x_msg_data,
1302: '_PUB');
1303: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1304: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1305: (l_api_name,
1306: G_PKG_NAME,
1307: 'OKC_API.G_RET_STS_UNEXP_ERROR',
1308: x_msg_count,

Line 1307: 'OKC_API.G_RET_STS_UNEXP_ERROR',

1303: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1304: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1305: (l_api_name,
1306: G_PKG_NAME,
1307: 'OKC_API.G_RET_STS_UNEXP_ERROR',
1308: x_msg_count,
1309: x_msg_data,
1310: '_PUB');
1311: WHEN OTHERS THEN

Line 1312: x_return_status := OKC_API.HANDLE_EXCEPTIONS

1308: x_msg_count,
1309: x_msg_data,
1310: '_PUB');
1311: WHEN OTHERS THEN
1312: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1313: (l_api_name,
1314: G_PKG_NAME,
1315: 'OTHERS',
1316: x_msg_count,

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

1325: x_msg_count OUT NOCOPY NUMBER,
1326: x_msg_data OUT NOCOPY VARCHAR2,
1327: p_savv_tbl IN savv_tbl_type) IS
1328: i NUMBER := 0;
1329: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1330:
1331: BEGIN
1332: x_return_status := OKC_API.G_RET_STS_SUCCESS;
1333: IF p_savv_tbl.COUNT > 0 THEN

Line 1332: x_return_status := OKC_API.G_RET_STS_SUCCESS;

1328: i NUMBER := 0;
1329: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1330:
1331: BEGIN
1332: x_return_status := OKC_API.G_RET_STS_SUCCESS;
1333: IF p_savv_tbl.COUNT > 0 THEN
1334: i := p_savv_tbl.FIRST;
1335: LOOP
1336: delete_std_art_version(

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

1339: x_return_status => l_return_status,
1340: x_msg_count => x_msg_count,
1341: x_msg_data => x_msg_data,
1342: p_savv_rec => p_savv_tbl(i));
1343: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1344: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1345: x_return_status := l_return_status;
1346: raise G_EXCEPTION_HALT_PROCESSING;
1347: ELSE

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

1340: x_msg_count => x_msg_count,
1341: x_msg_data => x_msg_data,
1342: p_savv_rec => p_savv_tbl(i));
1343: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1344: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1345: x_return_status := l_return_status;
1346: raise G_EXCEPTION_HALT_PROCESSING;
1347: ELSE
1348: x_return_status := l_return_status;

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

1355: EXCEPTION
1356: WHEN G_EXCEPTION_HALT_PROCESSING THEN
1357: NULL;
1358: WHEN OTHERS THEN
1359: OKC_API.set_message(p_app_name => g_app_name,
1360: p_msg_name => g_unexpected_error,
1361: p_token1 => g_sqlcode_token,
1362: p_token1_value => sqlcode,
1363: p_token2 => g_sqlerrm_token,

Line 1365: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

1361: p_token1 => g_sqlcode_token,
1362: p_token1_value => sqlcode,
1363: p_token2 => g_sqlerrm_token,
1364: p_token2_value => sqlerrm);
1365: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
1366: END delete_std_art_version;
1367:
1368: PROCEDURE validate_std_art_version(
1369: p_api_version IN NUMBER,

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

1392: x_msg_count OUT NOCOPY NUMBER,
1393: x_msg_data OUT NOCOPY VARCHAR2,
1394: p_savv_tbl IN savv_tbl_type) IS
1395: i NUMBER := 0;
1396: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1397:
1398: BEGIN
1399: x_return_status := OKC_API.G_RET_STS_SUCCESS;
1400: IF p_savv_tbl.COUNT > 0 THEN

Line 1399: x_return_status := OKC_API.G_RET_STS_SUCCESS;

1395: i NUMBER := 0;
1396: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1397:
1398: BEGIN
1399: x_return_status := OKC_API.G_RET_STS_SUCCESS;
1400: IF p_savv_tbl.COUNT > 0 THEN
1401: i := p_savv_tbl.FIRST;
1402: LOOP
1403: validate_std_art_version(

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

1406: x_return_status => l_return_status,
1407: x_msg_count => x_msg_count,
1408: x_msg_data => x_msg_data,
1409: p_savv_rec => p_savv_tbl(i));
1410: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1411: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1412: x_return_status := l_return_status;
1413: raise G_EXCEPTION_HALT_PROCESSING;
1414: ELSE

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

1407: x_msg_count => x_msg_count,
1408: x_msg_data => x_msg_data,
1409: p_savv_rec => p_savv_tbl(i));
1410: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1411: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1412: x_return_status := l_return_status;
1413: raise G_EXCEPTION_HALT_PROCESSING;
1414: ELSE
1415: x_return_status := l_return_status;

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

1422: EXCEPTION
1423: WHEN G_EXCEPTION_HALT_PROCESSING THEN
1424: NULL;
1425: WHEN OTHERS THEN
1426: OKC_API.set_message(p_app_name => g_app_name,
1427: p_msg_name => g_unexpected_error,
1428: p_token1 => g_sqlcode_token,
1429: p_token1_value => sqlcode,
1430: p_token2 => g_sqlerrm_token,

Line 1432: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

1428: p_token1 => g_sqlcode_token,
1429: p_token1_value => sqlcode,
1430: p_token2 => g_sqlerrm_token,
1431: p_token2_value => sqlerrm);
1432: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
1433: END validate_std_art_version;
1434:
1435: PROCEDURE validate_sav_release(
1436: p_api_version IN NUMBER,

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

1457: x_msg_data OUT NOCOPY VARCHAR2,
1458: p_savv_tbl IN savv_tbl_type) IS
1459:
1460: i NUMBER := 0;
1461: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1462:
1463: BEGIN
1464: x_return_status := OKC_API.G_RET_STS_SUCCESS;
1465: IF p_savv_tbl.COUNT > 0 THEN

Line 1464: x_return_status := OKC_API.G_RET_STS_SUCCESS;

1460: i NUMBER := 0;
1461: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1462:
1463: BEGIN
1464: x_return_status := OKC_API.G_RET_STS_SUCCESS;
1465: IF p_savv_tbl.COUNT > 0 THEN
1466: i := p_savv_tbl.FIRST;
1467: LOOP
1468: Validate_sav_release(p_api_version => p_api_version,

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

1471: x_msg_count => x_msg_count,
1472: x_msg_data => x_msg_data,
1473: p_savv_rec => p_savv_tbl(i));
1474:
1475: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1476: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1477: x_return_status := l_return_status;
1478: raise G_EXCEPTION_HALT_PROCESSING;
1479: ELSE

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

1472: x_msg_data => x_msg_data,
1473: p_savv_rec => p_savv_tbl(i));
1474:
1475: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1476: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1477: x_return_status := l_return_status;
1478: raise G_EXCEPTION_HALT_PROCESSING;
1479: ELSE
1480: x_return_status := l_return_status;

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

1487: EXCEPTION
1488: WHEN G_EXCEPTION_HALT_PROCESSING THEN
1489: NULL;
1490: WHEN OTHERS THEN
1491: OKC_API.set_message(p_app_name => g_app_name,
1492: p_msg_name => g_unexpected_error,
1493: p_token1 => g_sqlcode_token,
1494: p_token1_value => sqlcode,
1495: p_token2 => g_sqlerrm_token,

Line 1497: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

1493: p_token1 => g_sqlcode_token,
1494: p_token1_value => sqlcode,
1495: p_token2 => g_sqlerrm_token,
1496: p_token2_value => sqlerrm);
1497: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
1498: End Validate_sav_release;
1499:
1500:
1501: PROCEDURE validate_date_active(

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

1523: x_msg_data OUT NOCOPY VARCHAR2,
1524: p_savv_tbl IN savv_tbl_type) IS
1525:
1526: i NUMBER := 0;
1527: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1528:
1529: BEGIN
1530: x_return_status := OKC_API.G_RET_STS_SUCCESS;
1531: IF p_savv_tbl.COUNT > 0 THEN

Line 1530: x_return_status := OKC_API.G_RET_STS_SUCCESS;

1526: i NUMBER := 0;
1527: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1528:
1529: BEGIN
1530: x_return_status := OKC_API.G_RET_STS_SUCCESS;
1531: IF p_savv_tbl.COUNT > 0 THEN
1532: i := p_savv_tbl.FIRST;
1533: LOOP
1534: Validate_date_active(p_api_version => p_api_version,

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

1537: x_msg_count => x_msg_count,
1538: x_msg_data => x_msg_data,
1539: p_savv_rec => p_savv_tbl(i));
1540:
1541: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1542: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1543: x_return_status := l_return_status;
1544: raise G_EXCEPTION_HALT_PROCESSING;
1545: ELSE

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

1538: x_msg_data => x_msg_data,
1539: p_savv_rec => p_savv_tbl(i));
1540:
1541: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1542: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1543: x_return_status := l_return_status;
1544: raise G_EXCEPTION_HALT_PROCESSING;
1545: ELSE
1546: x_return_status := l_return_status;

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

1553: EXCEPTION
1554: WHEN G_EXCEPTION_HALT_PROCESSING THEN
1555: NULL;
1556: WHEN OTHERS THEN
1557: OKC_API.set_message(p_app_name => g_app_name,
1558: p_msg_name => g_unexpected_error,
1559: p_token1 => g_sqlcode_token,
1560: p_token1_value => sqlcode,
1561: p_token2 => g_sqlerrm_token,

Line 1563: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

1559: p_token1 => g_sqlcode_token,
1560: p_token1_value => sqlcode,
1561: p_token2 => g_sqlerrm_token,
1562: p_token2_value => sqlerrm);
1563: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
1564: End Validate_date_active;
1565:
1566:
1567: PROCEDURE validate_updatable(

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

1589: x_msg_data OUT NOCOPY VARCHAR2,
1590: p_savv_tbl IN savv_tbl_type) IS
1591:
1592: i NUMBER := 0;
1593: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1594:
1595: BEGIN
1596: x_return_status := OKC_API.G_RET_STS_SUCCESS;
1597: IF p_savv_tbl.COUNT > 0 THEN

Line 1596: x_return_status := OKC_API.G_RET_STS_SUCCESS;

1592: i NUMBER := 0;
1593: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1594:
1595: BEGIN
1596: x_return_status := OKC_API.G_RET_STS_SUCCESS;
1597: IF p_savv_tbl.COUNT > 0 THEN
1598: i := p_savv_tbl.FIRST;
1599: LOOP
1600: Validate_Updatable(p_api_version => p_api_version,

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

1603: x_msg_count => x_msg_count,
1604: x_msg_data => x_msg_data,
1605: p_savv_rec => p_savv_tbl(i));
1606:
1607: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1608: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1609: x_return_status := l_return_status;
1610: raise G_EXCEPTION_HALT_PROCESSING;
1611: ELSE

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

1604: x_msg_data => x_msg_data,
1605: p_savv_rec => p_savv_tbl(i));
1606:
1607: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1608: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1609: x_return_status := l_return_status;
1610: raise G_EXCEPTION_HALT_PROCESSING;
1611: ELSE
1612: x_return_status := l_return_status;

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

1619: EXCEPTION
1620: WHEN G_EXCEPTION_HALT_PROCESSING THEN
1621: NULL;
1622: WHEN OTHERS THEN
1623: OKC_API.set_message(p_app_name => g_app_name,
1624: p_msg_name => g_unexpected_error,
1625: p_token1 => g_sqlcode_token,
1626: p_token1_value => sqlcode,
1627: p_token2 => g_sqlerrm_token,

Line 1629: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

1625: p_token1 => g_sqlcode_token,
1626: p_token1_value => sqlcode,
1627: p_token2 => g_sqlerrm_token,
1628: p_token2_value => sqlerrm);
1629: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
1630:
1631: End Validate_Updatable;
1632:
1633: PROCEDURE validate_no_k_attached(

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

1644: p_savv_tbl IN savv_tbl_type,
1645: x_return_status OUT NOCOPY VARCHAR2) IS
1646:
1647: i NUMBER := 0;
1648: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1649:
1650: BEGIN
1651: x_return_status := OKC_API.G_RET_STS_SUCCESS;
1652: IF p_savv_tbl.COUNT > 0 THEN

Line 1651: x_return_status := OKC_API.G_RET_STS_SUCCESS;

1647: i NUMBER := 0;
1648: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1649:
1650: BEGIN
1651: x_return_status := OKC_API.G_RET_STS_SUCCESS;
1652: IF p_savv_tbl.COUNT > 0 THEN
1653: i := p_savv_tbl.FIRST;
1654: LOOP
1655: Validate_no_k_attached(

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

1655: Validate_no_k_attached(
1656: x_return_status => l_return_status,
1657: p_savv_rec => p_savv_tbl(i));
1658:
1659: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1660: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1661: x_return_status := l_return_status;
1662: raise G_EXCEPTION_HALT_PROCESSING;
1663: ELSE

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

1656: x_return_status => l_return_status,
1657: p_savv_rec => p_savv_tbl(i));
1658:
1659: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1660: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1661: x_return_status := l_return_status;
1662: raise G_EXCEPTION_HALT_PROCESSING;
1663: ELSE
1664: x_return_status := l_return_status;

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

1671: EXCEPTION
1672: WHEN G_EXCEPTION_HALT_PROCESSING THEN
1673: NULL;
1674: WHEN OTHERS THEN
1675: OKC_API.set_message(p_app_name => g_app_name,
1676: p_msg_name => g_unexpected_error,
1677: p_token1 => g_sqlcode_token,
1678: p_token1_value => sqlcode,
1679: p_token2 => g_sqlerrm_token,

Line 1681: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

1677: p_token1 => g_sqlcode_token,
1678: p_token1_value => sqlcode,
1679: p_token2 => g_sqlerrm_token,
1680: p_token2_value => sqlerrm);
1681: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
1682:
1683: End Validate_no_k_attached;
1684:
1685: PROCEDURE validate_latest(

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

1696: p_savv_tbl IN savv_tbl_type,
1697: x_return_status OUT NOCOPY VARCHAR2) IS
1698:
1699: i NUMBER := 0;
1700: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1701:
1702: BEGIN
1703: x_return_status := OKC_API.G_RET_STS_SUCCESS;
1704: IF p_savv_tbl.COUNT > 0 THEN

Line 1703: x_return_status := OKC_API.G_RET_STS_SUCCESS;

1699: i NUMBER := 0;
1700: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1701:
1702: BEGIN
1703: x_return_status := OKC_API.G_RET_STS_SUCCESS;
1704: IF p_savv_tbl.COUNT > 0 THEN
1705: i := p_savv_tbl.FIRST;
1706: LOOP
1707: Validate_latest(

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

1707: Validate_latest(
1708: x_return_status => l_return_status,
1709: p_savv_rec => p_savv_tbl(i));
1710:
1711: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1712: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1713: x_return_status := l_return_status;
1714: raise G_EXCEPTION_HALT_PROCESSING;
1715: ELSE

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

1708: x_return_status => l_return_status,
1709: p_savv_rec => p_savv_tbl(i));
1710:
1711: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1712: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1713: x_return_status := l_return_status;
1714: raise G_EXCEPTION_HALT_PROCESSING;
1715: ELSE
1716: x_return_status := l_return_status;

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

1723: EXCEPTION
1724: WHEN G_EXCEPTION_HALT_PROCESSING THEN
1725: NULL;
1726: WHEN OTHERS THEN
1727: OKC_API.set_message(p_app_name => g_app_name,
1728: p_msg_name => g_unexpected_error,
1729: p_token1 => g_sqlcode_token,
1730: p_token1_value => sqlcode,
1731: p_token2 => g_sqlerrm_token,

Line 1733: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

1729: p_token1 => g_sqlcode_token,
1730: p_token1_value => sqlcode,
1731: p_token2 => g_sqlerrm_token,
1732: p_token2_value => sqlerrm);
1733: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
1734:
1735: End Validate_latest;
1736:
1737: /*

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

1760: x_msg_data OUT NOCOPY VARCHAR2,
1761: p_savv_tbl IN savv_tbl_type) IS
1762:
1763: i NUMBER := 0;
1764: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1765:
1766: BEGIN
1767: x_return_status := OKC_API.G_RET_STS_SUCCESS;
1768: IF p_savv_tbl.COUNT > 0 THEN

Line 1767: x_return_status := OKC_API.G_RET_STS_SUCCESS;

1763: i NUMBER := 0;
1764: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1765:
1766: BEGIN
1767: x_return_status := OKC_API.G_RET_STS_SUCCESS;
1768: IF p_savv_tbl.COUNT > 0 THEN
1769: i := p_savv_tbl.FIRST;
1770: LOOP
1771: Validate_short_description(p_api_version => p_api_version,

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

1774: x_msg_count => x_msg_count,
1775: x_msg_data => x_msg_data,
1776: p_savv_rec => p_savv_tbl(i));
1777:
1778: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1779: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1780: x_return_status := l_return_status;
1781: raise G_EXCEPTION_HALT_PROCESSING;
1782: ELSE

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

1775: x_msg_data => x_msg_data,
1776: p_savv_rec => p_savv_tbl(i));
1777:
1778: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1779: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1780: x_return_status := l_return_status;
1781: raise G_EXCEPTION_HALT_PROCESSING;
1782: ELSE
1783: x_return_status := l_return_status;

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

1790: EXCEPTION
1791: WHEN G_EXCEPTION_HALT_PROCESSING THEN
1792: NULL;
1793: WHEN OTHERS THEN
1794: OKC_API.set_message(p_app_name => g_app_name,
1795: p_msg_name => g_unexpected_error,
1796: p_token1 => g_sqlcode_token,
1797: p_token1_value => sqlcode,
1798: p_token2 => g_sqlerrm_token,

Line 1800: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

1796: p_token1 => g_sqlcode_token,
1797: p_token1_value => sqlcode,
1798: p_token2 => g_sqlerrm_token,
1799: p_token2_value => sqlerrm);
1800: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
1801: End Validate_short_description;
1802: */
1803:
1804: PROCEDURE Create_std_art_incmpt(

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

1808: x_msg_count OUT NOCOPY NUMBER,
1809: x_msg_data OUT NOCOPY VARCHAR2,
1810: p_saiv_rec IN saiv_rec_type,
1811: x_saiv_rec OUT NOCOPY saiv_rec_type) IS
1812: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1813: l_api_name CONSTANT VARCHAR2(30) := 'CREATE_STD_ART_INCMPT';
1814: l_saiv_rec saiv_rec_type := p_saiv_rec;
1815: BEGIN
1816: l_return_status := OKC_API.START_ACTIVITY(l_api_name,

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

1812: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1813: l_api_name CONSTANT VARCHAR2(30) := 'CREATE_STD_ART_INCMPT';
1814: l_saiv_rec saiv_rec_type := p_saiv_rec;
1815: BEGIN
1816: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
1817: p_init_msg_list,
1818: '_PUB',
1819: x_return_status);
1820: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

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

1816: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
1817: p_init_msg_list,
1818: '_PUB',
1819: x_return_status);
1820: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1821: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1822: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1823: raise OKC_API.G_EXCEPTION_ERROR;
1824: END IF;

Line 1821: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1817: p_init_msg_list,
1818: '_PUB',
1819: x_return_status);
1820: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1821: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1822: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1823: raise OKC_API.G_EXCEPTION_ERROR;
1824: END IF;
1825: -- Call user hook for BEFORE

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

1818: '_PUB',
1819: x_return_status);
1820: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1821: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1822: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1823: raise OKC_API.G_EXCEPTION_ERROR;
1824: END IF;
1825: -- Call user hook for BEFORE
1826: g_saiv_rec := l_saiv_rec;

Line 1823: raise OKC_API.G_EXCEPTION_ERROR;

1819: x_return_status);
1820: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1821: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1822: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1823: raise OKC_API.G_EXCEPTION_ERROR;
1824: END IF;
1825: -- Call user hook for BEFORE
1826: g_saiv_rec := l_saiv_rec;
1827: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');

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

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

Line 1829: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

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

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

1826: g_saiv_rec := l_saiv_rec;
1827: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
1828: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1829: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1830: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1831: raise OKC_API.G_EXCEPTION_ERROR;
1832: END IF;
1833: l_saiv_rec := migrate_saiv(l_saiv_rec, g_saiv_rec);
1834:

Line 1831: raise OKC_API.G_EXCEPTION_ERROR;

1827: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
1828: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1829: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1830: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1831: raise OKC_API.G_EXCEPTION_ERROR;
1832: END IF;
1833: l_saiv_rec := migrate_saiv(l_saiv_rec, g_saiv_rec);
1834:
1835: OKC_STD_ARTICLE_PVT.create_std_art_incmpt(

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

1840: x_msg_data => x_msg_data,
1841: p_saiv_rec => l_saiv_rec,
1842: x_saiv_rec => x_saiv_rec);
1843:
1844: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1845: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1846: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1847: raise OKC_API.G_EXCEPTION_ERROR;
1848: END IF;

Line 1845: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1841: p_saiv_rec => l_saiv_rec,
1842: x_saiv_rec => x_saiv_rec);
1843:
1844: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1845: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1846: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1847: raise OKC_API.G_EXCEPTION_ERROR;
1848: END IF;
1849:

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

1842: x_saiv_rec => x_saiv_rec);
1843:
1844: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1845: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1846: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1847: raise OKC_API.G_EXCEPTION_ERROR;
1848: END IF;
1849:
1850: -- Call user hook for AFTER

Line 1847: raise OKC_API.G_EXCEPTION_ERROR;

1843:
1844: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1845: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1846: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1847: raise OKC_API.G_EXCEPTION_ERROR;
1848: END IF;
1849:
1850: -- Call user hook for AFTER
1851: g_saiv_rec := x_saiv_rec;

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

1849:
1850: -- Call user hook for AFTER
1851: g_saiv_rec := x_saiv_rec;
1852: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
1853: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1854: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1855: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1856: raise OKC_API.G_EXCEPTION_ERROR;
1857: END IF;

Line 1854: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1850: -- Call user hook for AFTER
1851: g_saiv_rec := x_saiv_rec;
1852: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
1853: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1854: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1855: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1856: raise OKC_API.G_EXCEPTION_ERROR;
1857: END IF;
1858: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

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

1851: g_saiv_rec := x_saiv_rec;
1852: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
1853: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1854: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1855: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1856: raise OKC_API.G_EXCEPTION_ERROR;
1857: END IF;
1858: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1859: EXCEPTION

Line 1856: raise OKC_API.G_EXCEPTION_ERROR;

1852: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
1853: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1854: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1855: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1856: raise OKC_API.G_EXCEPTION_ERROR;
1857: END IF;
1858: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1859: EXCEPTION
1860: WHEN OKC_API.G_EXCEPTION_ERROR THEN

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

1854: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1855: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1856: raise OKC_API.G_EXCEPTION_ERROR;
1857: END IF;
1858: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1859: EXCEPTION
1860: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1861: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1862: (l_api_name,

Line 1860: WHEN OKC_API.G_EXCEPTION_ERROR THEN

1856: raise OKC_API.G_EXCEPTION_ERROR;
1857: END IF;
1858: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1859: EXCEPTION
1860: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1861: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1862: (l_api_name,
1863: G_PKG_NAME,
1864: 'OKC_API.G_RET_STS_ERROR',

Line 1861: x_return_status := OKC_API.HANDLE_EXCEPTIONS

1857: END IF;
1858: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1859: EXCEPTION
1860: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1861: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1862: (l_api_name,
1863: G_PKG_NAME,
1864: 'OKC_API.G_RET_STS_ERROR',
1865: x_msg_count,

Line 1864: 'OKC_API.G_RET_STS_ERROR',

1860: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1861: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1862: (l_api_name,
1863: G_PKG_NAME,
1864: 'OKC_API.G_RET_STS_ERROR',
1865: x_msg_count,
1866: x_msg_data,
1867: '_PUB');
1868: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

Line 1868: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

1864: 'OKC_API.G_RET_STS_ERROR',
1865: x_msg_count,
1866: x_msg_data,
1867: '_PUB');
1868: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1869: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1870: (l_api_name,
1871: G_PKG_NAME,
1872: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 1869: x_return_status := OKC_API.HANDLE_EXCEPTIONS

1865: x_msg_count,
1866: x_msg_data,
1867: '_PUB');
1868: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1869: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1870: (l_api_name,
1871: G_PKG_NAME,
1872: 'OKC_API.G_RET_STS_UNEXP_ERROR',
1873: x_msg_count,

Line 1872: 'OKC_API.G_RET_STS_UNEXP_ERROR',

1868: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1869: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1870: (l_api_name,
1871: G_PKG_NAME,
1872: 'OKC_API.G_RET_STS_UNEXP_ERROR',
1873: x_msg_count,
1874: x_msg_data,
1875: '_PUB');
1876: WHEN OTHERS THEN

Line 1877: x_return_status := OKC_API.HANDLE_EXCEPTIONS

1873: x_msg_count,
1874: x_msg_data,
1875: '_PUB');
1876: WHEN OTHERS THEN
1877: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1878: (l_api_name,
1879: G_PKG_NAME,
1880: 'OTHERS',
1881: x_msg_count,

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

1892: x_msg_data OUT NOCOPY VARCHAR2,
1893: p_saiv_tbl IN saiv_tbl_type,
1894: x_saiv_tbl OUT NOCOPY saiv_tbl_type) IS
1895: i NUMBER := 0;
1896: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1897:
1898: BEGIN
1899: x_return_status := OKC_API.G_RET_STS_SUCCESS;
1900: IF p_saiv_tbl.COUNT > 0 THEN

Line 1899: x_return_status := OKC_API.G_RET_STS_SUCCESS;

1895: i NUMBER := 0;
1896: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1897:
1898: BEGIN
1899: x_return_status := OKC_API.G_RET_STS_SUCCESS;
1900: IF p_saiv_tbl.COUNT > 0 THEN
1901: i := p_saiv_tbl.FIRST;
1902: LOOP
1903: create_std_art_incmpt(

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

1907: x_msg_count => x_msg_count,
1908: x_msg_data => x_msg_data,
1909: p_saiv_rec => p_saiv_tbl(i),
1910: x_saiv_rec => x_saiv_tbl(i));
1911: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1912: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1913: x_return_status := l_return_status;
1914: raise G_EXCEPTION_HALT_PROCESSING;
1915: ELSE

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

1908: x_msg_data => x_msg_data,
1909: p_saiv_rec => p_saiv_tbl(i),
1910: x_saiv_rec => x_saiv_tbl(i));
1911: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1912: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1913: x_return_status := l_return_status;
1914: raise G_EXCEPTION_HALT_PROCESSING;
1915: ELSE
1916: x_return_status := l_return_status;

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

1923: EXCEPTION
1924: WHEN G_EXCEPTION_HALT_PROCESSING THEN
1925: NULL;
1926: WHEN OTHERS THEN
1927: OKC_API.set_message(p_app_name => g_app_name,
1928: p_msg_name => g_unexpected_error,
1929: p_token1 => g_sqlcode_token,
1930: p_token1_value => sqlcode,
1931: p_token2 => g_sqlerrm_token,

Line 1933: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

1929: p_token1 => g_sqlcode_token,
1930: p_token1_value => sqlcode,
1931: p_token2 => g_sqlerrm_token,
1932: p_token2_value => sqlerrm);
1933: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
1934: END Create_std_art_incmpt;
1935:
1936: PROCEDURE update_std_art_incmpt(
1937: p_api_version IN NUMBER,

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

1940: x_msg_count OUT NOCOPY NUMBER,
1941: x_msg_data OUT NOCOPY VARCHAR2,
1942: p_saiv_rec IN saiv_rec_type,
1943: x_saiv_rec OUT NOCOPY saiv_rec_type) IS
1944: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1945: l_api_name CONSTANT VARCHAR2(30) := 'UPDATE_STD_ART_INCMPT';
1946: l_saiv_rec saiv_rec_type := p_saiv_rec;
1947: BEGIN
1948: l_return_status := OKC_API.START_ACTIVITY(l_api_name,

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

1944: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1945: l_api_name CONSTANT VARCHAR2(30) := 'UPDATE_STD_ART_INCMPT';
1946: l_saiv_rec saiv_rec_type := p_saiv_rec;
1947: BEGIN
1948: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
1949: p_init_msg_list,
1950: '_PUB',
1951: x_return_status);
1952: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

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

1948: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
1949: p_init_msg_list,
1950: '_PUB',
1951: x_return_status);
1952: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1953: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1954: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1955: raise OKC_API.G_EXCEPTION_ERROR;
1956: END IF;

Line 1953: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1949: p_init_msg_list,
1950: '_PUB',
1951: x_return_status);
1952: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1953: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1954: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1955: raise OKC_API.G_EXCEPTION_ERROR;
1956: END IF;
1957: -- Call user hook for BEFORE

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

1950: '_PUB',
1951: x_return_status);
1952: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1953: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1954: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1955: raise OKC_API.G_EXCEPTION_ERROR;
1956: END IF;
1957: -- Call user hook for BEFORE
1958: g_saiv_rec := l_saiv_rec;

Line 1955: raise OKC_API.G_EXCEPTION_ERROR;

1951: x_return_status);
1952: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1953: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1954: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1955: raise OKC_API.G_EXCEPTION_ERROR;
1956: END IF;
1957: -- Call user hook for BEFORE
1958: g_saiv_rec := l_saiv_rec;
1959: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');

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

1956: END IF;
1957: -- Call user hook for BEFORE
1958: g_saiv_rec := l_saiv_rec;
1959: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
1960: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1961: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1962: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1963: raise OKC_API.G_EXCEPTION_ERROR;
1964: END IF;

Line 1961: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1957: -- Call user hook for BEFORE
1958: g_saiv_rec := l_saiv_rec;
1959: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
1960: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1961: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1962: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1963: raise OKC_API.G_EXCEPTION_ERROR;
1964: END IF;
1965: l_saiv_rec := migrate_saiv(l_saiv_rec, g_saiv_rec);

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

1958: g_saiv_rec := l_saiv_rec;
1959: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
1960: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1961: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1962: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1963: raise OKC_API.G_EXCEPTION_ERROR;
1964: END IF;
1965: l_saiv_rec := migrate_saiv(l_saiv_rec, g_saiv_rec);
1966:

Line 1963: raise OKC_API.G_EXCEPTION_ERROR;

1959: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
1960: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1961: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1962: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1963: raise OKC_API.G_EXCEPTION_ERROR;
1964: END IF;
1965: l_saiv_rec := migrate_saiv(l_saiv_rec, g_saiv_rec);
1966:
1967: OKC_STD_ARTICLE_PVT.update_std_art_incmpt(

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

1972: x_msg_data => x_msg_data,
1973: p_saiv_rec => l_saiv_rec,
1974: x_saiv_rec => x_saiv_rec);
1975:
1976: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1977: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1978: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1979: raise OKC_API.G_EXCEPTION_ERROR;
1980: END IF;

Line 1977: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1973: p_saiv_rec => l_saiv_rec,
1974: x_saiv_rec => x_saiv_rec);
1975:
1976: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1977: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1978: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1979: raise OKC_API.G_EXCEPTION_ERROR;
1980: END IF;
1981:

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

1974: x_saiv_rec => x_saiv_rec);
1975:
1976: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1977: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1978: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1979: raise OKC_API.G_EXCEPTION_ERROR;
1980: END IF;
1981:
1982: -- Call user hook for AFTER

Line 1979: raise OKC_API.G_EXCEPTION_ERROR;

1975:
1976: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1977: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1978: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1979: raise OKC_API.G_EXCEPTION_ERROR;
1980: END IF;
1981:
1982: -- Call user hook for AFTER
1983: g_saiv_rec := x_saiv_rec;

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

1981:
1982: -- Call user hook for AFTER
1983: g_saiv_rec := x_saiv_rec;
1984: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
1985: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1986: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1987: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1988: raise OKC_API.G_EXCEPTION_ERROR;
1989: END IF;

Line 1986: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1982: -- Call user hook for AFTER
1983: g_saiv_rec := x_saiv_rec;
1984: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
1985: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1986: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1987: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1988: raise OKC_API.G_EXCEPTION_ERROR;
1989: END IF;
1990: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

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

1983: g_saiv_rec := x_saiv_rec;
1984: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
1985: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1986: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1987: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1988: raise OKC_API.G_EXCEPTION_ERROR;
1989: END IF;
1990: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1991: EXCEPTION

Line 1988: raise OKC_API.G_EXCEPTION_ERROR;

1984: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
1985: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1986: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1987: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1988: raise OKC_API.G_EXCEPTION_ERROR;
1989: END IF;
1990: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1991: EXCEPTION
1992: WHEN OKC_API.G_EXCEPTION_ERROR THEN

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

1986: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1987: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1988: raise OKC_API.G_EXCEPTION_ERROR;
1989: END IF;
1990: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1991: EXCEPTION
1992: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1993: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1994: (l_api_name,

Line 1992: WHEN OKC_API.G_EXCEPTION_ERROR THEN

1988: raise OKC_API.G_EXCEPTION_ERROR;
1989: END IF;
1990: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1991: EXCEPTION
1992: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1993: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1994: (l_api_name,
1995: G_PKG_NAME,
1996: 'OKC_API.G_RET_STS_ERROR',

Line 1993: x_return_status := OKC_API.HANDLE_EXCEPTIONS

1989: END IF;
1990: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1991: EXCEPTION
1992: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1993: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1994: (l_api_name,
1995: G_PKG_NAME,
1996: 'OKC_API.G_RET_STS_ERROR',
1997: x_msg_count,

Line 1996: 'OKC_API.G_RET_STS_ERROR',

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

Line 2000: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

1996: 'OKC_API.G_RET_STS_ERROR',
1997: x_msg_count,
1998: x_msg_data,
1999: '_PUB');
2000: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
2001: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2002: (l_api_name,
2003: G_PKG_NAME,
2004: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 2001: x_return_status := OKC_API.HANDLE_EXCEPTIONS

1997: x_msg_count,
1998: x_msg_data,
1999: '_PUB');
2000: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
2001: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2002: (l_api_name,
2003: G_PKG_NAME,
2004: 'OKC_API.G_RET_STS_UNEXP_ERROR',
2005: x_msg_count,

Line 2004: 'OKC_API.G_RET_STS_UNEXP_ERROR',

2000: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
2001: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2002: (l_api_name,
2003: G_PKG_NAME,
2004: 'OKC_API.G_RET_STS_UNEXP_ERROR',
2005: x_msg_count,
2006: x_msg_data,
2007: '_PUB');
2008: WHEN OTHERS THEN

Line 2009: x_return_status := OKC_API.HANDLE_EXCEPTIONS

2005: x_msg_count,
2006: x_msg_data,
2007: '_PUB');
2008: WHEN OTHERS THEN
2009: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2010: (l_api_name,
2011: G_PKG_NAME,
2012: 'OTHERS',
2013: x_msg_count,

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

2023: x_msg_data OUT NOCOPY VARCHAR2,
2024: p_saiv_tbl IN saiv_tbl_type,
2025: x_saiv_tbl OUT NOCOPY saiv_tbl_type) IS
2026: i NUMBER := 0;
2027: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2028:
2029: BEGIN
2030: x_return_status := OKC_API.G_RET_STS_SUCCESS;
2031: IF p_saiv_tbl.COUNT > 0 THEN

Line 2030: x_return_status := OKC_API.G_RET_STS_SUCCESS;

2026: i NUMBER := 0;
2027: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2028:
2029: BEGIN
2030: x_return_status := OKC_API.G_RET_STS_SUCCESS;
2031: IF p_saiv_tbl.COUNT > 0 THEN
2032: i := p_saiv_tbl.FIRST;
2033: LOOP
2034: update_std_art_incmpt(

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

2038: x_msg_count => x_msg_count,
2039: x_msg_data => x_msg_data,
2040: p_saiv_rec => p_saiv_tbl(i),
2041: x_saiv_rec => x_saiv_tbl(i));
2042: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2043: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2044: x_return_status := l_return_status;
2045: raise G_EXCEPTION_HALT_PROCESSING;
2046: ELSE

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

2039: x_msg_data => x_msg_data,
2040: p_saiv_rec => p_saiv_tbl(i),
2041: x_saiv_rec => x_saiv_tbl(i));
2042: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2043: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2044: x_return_status := l_return_status;
2045: raise G_EXCEPTION_HALT_PROCESSING;
2046: ELSE
2047: x_return_status := l_return_status;

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

2054: EXCEPTION
2055: WHEN G_EXCEPTION_HALT_PROCESSING THEN
2056: NULL;
2057: WHEN OTHERS THEN
2058: OKC_API.set_message(p_app_name => g_app_name,
2059: p_msg_name => g_unexpected_error,
2060: p_token1 => g_sqlcode_token,
2061: p_token1_value => sqlcode,
2062: p_token2 => g_sqlerrm_token,

Line 2064: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

2060: p_token1 => g_sqlcode_token,
2061: p_token1_value => sqlcode,
2062: p_token2 => g_sqlerrm_token,
2063: p_token2_value => sqlerrm);
2064: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
2065: END update_std_art_incmpt;
2066:
2067: PROCEDURE lock_std_art_incmpt(
2068: p_api_version IN NUMBER,

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

2089: x_msg_count OUT NOCOPY NUMBER,
2090: x_msg_data OUT NOCOPY VARCHAR2,
2091: p_saiv_tbl IN saiv_tbl_type) IS
2092: i NUMBER := 0;
2093: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2094:
2095: BEGIN
2096: x_return_status := OKC_API.G_RET_STS_SUCCESS;
2097: IF p_saiv_tbl.COUNT > 0 THEN

Line 2096: x_return_status := OKC_API.G_RET_STS_SUCCESS;

2092: i NUMBER := 0;
2093: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2094:
2095: BEGIN
2096: x_return_status := OKC_API.G_RET_STS_SUCCESS;
2097: IF p_saiv_tbl.COUNT > 0 THEN
2098: i := p_saiv_tbl.FIRST;
2099: LOOP
2100: lock_std_art_incmpt(

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

2103: x_return_status => l_return_status,
2104: x_msg_count => x_msg_count,
2105: x_msg_data => x_msg_data,
2106: p_saiv_rec => p_saiv_tbl(i));
2107: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2108: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2109: x_return_status := l_return_status;
2110: raise G_EXCEPTION_HALT_PROCESSING;
2111: ELSE

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

2104: x_msg_count => x_msg_count,
2105: x_msg_data => x_msg_data,
2106: p_saiv_rec => p_saiv_tbl(i));
2107: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2108: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2109: x_return_status := l_return_status;
2110: raise G_EXCEPTION_HALT_PROCESSING;
2111: ELSE
2112: x_return_status := l_return_status;

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

2119: EXCEPTION
2120: WHEN G_EXCEPTION_HALT_PROCESSING THEN
2121: NULL;
2122: WHEN OTHERS THEN
2123: OKC_API.set_message(p_app_name => g_app_name,
2124: p_msg_name => g_unexpected_error,
2125: p_token1 => g_sqlcode_token,
2126: p_token1_value => sqlcode,
2127: p_token2 => g_sqlerrm_token,

Line 2129: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

2125: p_token1 => g_sqlcode_token,
2126: p_token1_value => sqlcode,
2127: p_token2 => g_sqlerrm_token,
2128: p_token2_value => sqlerrm);
2129: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
2130: END lock_std_art_incmpt;
2131:
2132: PROCEDURE delete_std_art_incmpt(
2133: p_api_version IN NUMBER,

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

2135: x_return_status OUT NOCOPY VARCHAR2,
2136: x_msg_count OUT NOCOPY NUMBER,
2137: x_msg_data OUT NOCOPY VARCHAR2,
2138: p_saiv_rec IN saiv_rec_type) IS
2139: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2140: l_api_name CONSTANT VARCHAR2(30) := 'DELETE_STD_ART_INCMPT';
2141: l_saiv_rec saiv_rec_type := p_saiv_rec;
2142: BEGIN
2143: l_return_status := OKC_API.START_ACTIVITY(l_api_name,

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

2139: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2140: l_api_name CONSTANT VARCHAR2(30) := 'DELETE_STD_ART_INCMPT';
2141: l_saiv_rec saiv_rec_type := p_saiv_rec;
2142: BEGIN
2143: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
2144: p_init_msg_list,
2145: '_PUB',
2146: x_return_status);
2147: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

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

2143: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
2144: p_init_msg_list,
2145: '_PUB',
2146: x_return_status);
2147: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2148: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2149: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2150: raise OKC_API.G_EXCEPTION_ERROR;
2151: END IF;

Line 2148: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2144: p_init_msg_list,
2145: '_PUB',
2146: x_return_status);
2147: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2148: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2149: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2150: raise OKC_API.G_EXCEPTION_ERROR;
2151: END IF;
2152: -- Call user hook for BEFORE

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

2145: '_PUB',
2146: x_return_status);
2147: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2148: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2149: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2150: raise OKC_API.G_EXCEPTION_ERROR;
2151: END IF;
2152: -- Call user hook for BEFORE
2153: g_saiv_rec := l_saiv_rec;

Line 2150: raise OKC_API.G_EXCEPTION_ERROR;

2146: x_return_status);
2147: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2148: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2149: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2150: raise OKC_API.G_EXCEPTION_ERROR;
2151: END IF;
2152: -- Call user hook for BEFORE
2153: g_saiv_rec := l_saiv_rec;
2154: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');

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

2151: END IF;
2152: -- Call user hook for BEFORE
2153: g_saiv_rec := l_saiv_rec;
2154: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
2155: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2156: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2157: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2158: raise OKC_API.G_EXCEPTION_ERROR;
2159: END IF;

Line 2156: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2152: -- Call user hook for BEFORE
2153: g_saiv_rec := l_saiv_rec;
2154: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
2155: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2156: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2157: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2158: raise OKC_API.G_EXCEPTION_ERROR;
2159: END IF;
2160: l_saiv_rec := migrate_saiv(l_saiv_rec, g_saiv_rec);

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

2153: g_saiv_rec := l_saiv_rec;
2154: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
2155: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2156: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2157: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2158: raise OKC_API.G_EXCEPTION_ERROR;
2159: END IF;
2160: l_saiv_rec := migrate_saiv(l_saiv_rec, g_saiv_rec);
2161:

Line 2158: raise OKC_API.G_EXCEPTION_ERROR;

2154: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
2155: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2156: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2157: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2158: raise OKC_API.G_EXCEPTION_ERROR;
2159: END IF;
2160: l_saiv_rec := migrate_saiv(l_saiv_rec, g_saiv_rec);
2161:
2162: OKC_STD_ARTICLE_PVT.delete_std_art_incmpt(

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

2166: x_msg_count => x_msg_count,
2167: x_msg_data => x_msg_data,
2168: p_saiv_rec => l_saiv_rec);
2169:
2170: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2171: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2172: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2173: raise OKC_API.G_EXCEPTION_ERROR;
2174: END IF;

Line 2171: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2167: x_msg_data => x_msg_data,
2168: p_saiv_rec => l_saiv_rec);
2169:
2170: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2171: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2172: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2173: raise OKC_API.G_EXCEPTION_ERROR;
2174: END IF;
2175:

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

2168: p_saiv_rec => l_saiv_rec);
2169:
2170: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2171: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2172: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2173: raise OKC_API.G_EXCEPTION_ERROR;
2174: END IF;
2175:
2176: -- Call user hook for AFTER

Line 2173: raise OKC_API.G_EXCEPTION_ERROR;

2169:
2170: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2171: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2172: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2173: raise OKC_API.G_EXCEPTION_ERROR;
2174: END IF;
2175:
2176: -- Call user hook for AFTER
2177: g_saiv_rec := l_saiv_rec;

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

2175:
2176: -- Call user hook for AFTER
2177: g_saiv_rec := l_saiv_rec;
2178: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
2179: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2180: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2181: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2182: raise OKC_API.G_EXCEPTION_ERROR;
2183: END IF;

Line 2180: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2176: -- Call user hook for AFTER
2177: g_saiv_rec := l_saiv_rec;
2178: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
2179: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2180: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2181: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2182: raise OKC_API.G_EXCEPTION_ERROR;
2183: END IF;
2184: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

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

2177: g_saiv_rec := l_saiv_rec;
2178: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
2179: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2180: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2181: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2182: raise OKC_API.G_EXCEPTION_ERROR;
2183: END IF;
2184: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
2185: EXCEPTION

Line 2182: raise OKC_API.G_EXCEPTION_ERROR;

2178: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
2179: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2180: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2181: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2182: raise OKC_API.G_EXCEPTION_ERROR;
2183: END IF;
2184: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
2185: EXCEPTION
2186: WHEN OKC_API.G_EXCEPTION_ERROR THEN

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

2180: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2181: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2182: raise OKC_API.G_EXCEPTION_ERROR;
2183: END IF;
2184: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
2185: EXCEPTION
2186: WHEN OKC_API.G_EXCEPTION_ERROR THEN
2187: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2188: (l_api_name,

Line 2186: WHEN OKC_API.G_EXCEPTION_ERROR THEN

2182: raise OKC_API.G_EXCEPTION_ERROR;
2183: END IF;
2184: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
2185: EXCEPTION
2186: WHEN OKC_API.G_EXCEPTION_ERROR THEN
2187: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2188: (l_api_name,
2189: G_PKG_NAME,
2190: 'OKC_API.G_RET_STS_ERROR',

Line 2187: x_return_status := OKC_API.HANDLE_EXCEPTIONS

2183: END IF;
2184: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
2185: EXCEPTION
2186: WHEN OKC_API.G_EXCEPTION_ERROR THEN
2187: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2188: (l_api_name,
2189: G_PKG_NAME,
2190: 'OKC_API.G_RET_STS_ERROR',
2191: x_msg_count,

Line 2190: 'OKC_API.G_RET_STS_ERROR',

2186: WHEN OKC_API.G_EXCEPTION_ERROR THEN
2187: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2188: (l_api_name,
2189: G_PKG_NAME,
2190: 'OKC_API.G_RET_STS_ERROR',
2191: x_msg_count,
2192: x_msg_data,
2193: '_PUB');
2194: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

Line 2194: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

2190: 'OKC_API.G_RET_STS_ERROR',
2191: x_msg_count,
2192: x_msg_data,
2193: '_PUB');
2194: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
2195: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2196: (l_api_name,
2197: G_PKG_NAME,
2198: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 2195: x_return_status := OKC_API.HANDLE_EXCEPTIONS

2191: x_msg_count,
2192: x_msg_data,
2193: '_PUB');
2194: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
2195: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2196: (l_api_name,
2197: G_PKG_NAME,
2198: 'OKC_API.G_RET_STS_UNEXP_ERROR',
2199: x_msg_count,

Line 2198: 'OKC_API.G_RET_STS_UNEXP_ERROR',

2194: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
2195: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2196: (l_api_name,
2197: G_PKG_NAME,
2198: 'OKC_API.G_RET_STS_UNEXP_ERROR',
2199: x_msg_count,
2200: x_msg_data,
2201: '_PUB');
2202: WHEN OTHERS THEN

Line 2203: x_return_status := OKC_API.HANDLE_EXCEPTIONS

2199: x_msg_count,
2200: x_msg_data,
2201: '_PUB');
2202: WHEN OTHERS THEN
2203: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2204: (l_api_name,
2205: G_PKG_NAME,
2206: 'OTHERS',
2207: x_msg_count,

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

2216: x_msg_count OUT NOCOPY NUMBER,
2217: x_msg_data OUT NOCOPY VARCHAR2,
2218: p_saiv_tbl IN saiv_tbl_type) IS
2219: i NUMBER := 0;
2220: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2221:
2222: BEGIN
2223: x_return_status := OKC_API.G_RET_STS_SUCCESS;
2224: IF p_saiv_tbl.COUNT > 0 THEN

Line 2223: x_return_status := OKC_API.G_RET_STS_SUCCESS;

2219: i NUMBER := 0;
2220: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2221:
2222: BEGIN
2223: x_return_status := OKC_API.G_RET_STS_SUCCESS;
2224: IF p_saiv_tbl.COUNT > 0 THEN
2225: i := p_saiv_tbl.FIRST;
2226: LOOP
2227: delete_std_art_incmpt(

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

2230: x_return_status => l_return_status,
2231: x_msg_count => x_msg_count,
2232: x_msg_data => x_msg_data,
2233: p_saiv_rec => p_saiv_tbl(i));
2234: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2235: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2236: x_return_status := l_return_status;
2237: raise G_EXCEPTION_HALT_PROCESSING;
2238: ELSE

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

2231: x_msg_count => x_msg_count,
2232: x_msg_data => x_msg_data,
2233: p_saiv_rec => p_saiv_tbl(i));
2234: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2235: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2236: x_return_status := l_return_status;
2237: raise G_EXCEPTION_HALT_PROCESSING;
2238: ELSE
2239: x_return_status := l_return_status;

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

2246: EXCEPTION
2247: WHEN G_EXCEPTION_HALT_PROCESSING THEN
2248: NULL;
2249: WHEN OTHERS THEN
2250: OKC_API.set_message(p_app_name => g_app_name,
2251: p_msg_name => g_unexpected_error,
2252: p_token1 => g_sqlcode_token,
2253: p_token1_value => sqlcode,
2254: p_token2 => g_sqlerrm_token,

Line 2256: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

2252: p_token1 => g_sqlcode_token,
2253: p_token1_value => sqlcode,
2254: p_token2 => g_sqlerrm_token,
2255: p_token2_value => sqlerrm);
2256: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
2257: END delete_std_art_incmpt;
2258:
2259: PROCEDURE validate_std_art_incmpt(
2260: p_api_version IN NUMBER,

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

2283: x_msg_count OUT NOCOPY NUMBER,
2284: x_msg_data OUT NOCOPY VARCHAR2,
2285: p_saiv_tbl IN saiv_tbl_type) IS
2286: i NUMBER := 0;
2287: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2288:
2289: BEGIN
2290: x_return_status := OKC_API.G_RET_STS_SUCCESS;
2291: IF p_saiv_tbl.COUNT > 0 THEN

Line 2290: x_return_status := OKC_API.G_RET_STS_SUCCESS;

2286: i NUMBER := 0;
2287: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2288:
2289: BEGIN
2290: x_return_status := OKC_API.G_RET_STS_SUCCESS;
2291: IF p_saiv_tbl.COUNT > 0 THEN
2292: i := p_saiv_tbl.FIRST;
2293: LOOP
2294: validate_std_art_incmpt(

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

2297: x_return_status => l_return_status,
2298: x_msg_count => x_msg_count,
2299: x_msg_data => x_msg_data,
2300: p_saiv_rec => p_saiv_tbl(i));
2301: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2302: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2303: x_return_status := l_return_status;
2304: raise G_EXCEPTION_HALT_PROCESSING;
2305: ELSE

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

2298: x_msg_count => x_msg_count,
2299: x_msg_data => x_msg_data,
2300: p_saiv_rec => p_saiv_tbl(i));
2301: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2302: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2303: x_return_status := l_return_status;
2304: raise G_EXCEPTION_HALT_PROCESSING;
2305: ELSE
2306: x_return_status := l_return_status;

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

2313: EXCEPTION
2314: WHEN G_EXCEPTION_HALT_PROCESSING THEN
2315: NULL;
2316: WHEN OTHERS THEN
2317: OKC_API.set_message(p_app_name => g_app_name,
2318: p_msg_name => g_unexpected_error,
2319: p_token1 => g_sqlcode_token,
2320: p_token1_value => sqlcode,
2321: p_token2 => g_sqlerrm_token,

Line 2323: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

2319: p_token1 => g_sqlcode_token,
2320: p_token1_value => sqlcode,
2321: p_token2 => g_sqlerrm_token,
2322: p_token2_value => sqlerrm);
2323: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
2324: END validate_std_art_incmpt;
2325:
2326:
2327: PROCEDURE validate_unique(

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

2349: x_msg_data OUT NOCOPY VARCHAR2,
2350: p_saiv_tbl IN saiv_tbl_type) IS
2351:
2352: i NUMBER := 0;
2353: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2354:
2355: BEGIN
2356: x_return_status := OKC_API.G_RET_STS_SUCCESS;
2357: IF p_saiv_tbl.COUNT > 0 THEN

Line 2356: x_return_status := OKC_API.G_RET_STS_SUCCESS;

2352: i NUMBER := 0;
2353: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2354:
2355: BEGIN
2356: x_return_status := OKC_API.G_RET_STS_SUCCESS;
2357: IF p_saiv_tbl.COUNT > 0 THEN
2358: i := p_saiv_tbl.FIRST;
2359: LOOP
2360: Validate_unique(p_api_version => p_api_version,

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

2363: x_msg_count => x_msg_count,
2364: x_msg_data => x_msg_data,
2365: p_saiv_rec => p_saiv_tbl(i));
2366:
2367: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2368: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2369: x_return_status := l_return_status;
2370: raise G_EXCEPTION_HALT_PROCESSING;
2371: ELSE

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

2364: x_msg_data => x_msg_data,
2365: p_saiv_rec => p_saiv_tbl(i));
2366:
2367: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2368: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2369: x_return_status := l_return_status;
2370: raise G_EXCEPTION_HALT_PROCESSING;
2371: ELSE
2372: x_return_status := l_return_status;

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

2379: EXCEPTION
2380: WHEN G_EXCEPTION_HALT_PROCESSING THEN
2381: NULL;
2382: WHEN OTHERS THEN
2383: OKC_API.set_message(p_app_name => g_app_name,
2384: p_msg_name => g_unexpected_error,
2385: p_token1 => g_sqlcode_token,
2386: p_token1_value => sqlcode,
2387: p_token2 => g_sqlerrm_token,

Line 2389: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

2385: p_token1 => g_sqlcode_token,
2386: p_token1_value => sqlcode,
2387: p_token2 => g_sqlerrm_token,
2388: p_token2_value => sqlerrm);
2389: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
2390: End Validate_unique;
2391:
2392:
2393: PROCEDURE create_std_art_classing(

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

2397: x_msg_count OUT NOCOPY NUMBER,
2398: x_msg_data OUT NOCOPY VARCHAR2,
2399: p_sacv_rec IN sacv_rec_type,
2400: x_sacv_rec OUT NOCOPY sacv_rec_type) IS
2401: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2402: l_api_name CONSTANT VARCHAR2(30) := 'CREATE_STD_ART_CLASSING';
2403: l_sacv_rec sacv_rec_type := p_sacv_rec;
2404: BEGIN
2405: l_return_status := OKC_API.START_ACTIVITY(l_api_name,

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

2401: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2402: l_api_name CONSTANT VARCHAR2(30) := 'CREATE_STD_ART_CLASSING';
2403: l_sacv_rec sacv_rec_type := p_sacv_rec;
2404: BEGIN
2405: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
2406: p_init_msg_list,
2407: '_PUB',
2408: x_return_status);
2409: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

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

2405: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
2406: p_init_msg_list,
2407: '_PUB',
2408: x_return_status);
2409: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2410: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2411: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2412: raise OKC_API.G_EXCEPTION_ERROR;
2413: END IF;

Line 2410: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2406: p_init_msg_list,
2407: '_PUB',
2408: x_return_status);
2409: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2410: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2411: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2412: raise OKC_API.G_EXCEPTION_ERROR;
2413: END IF;
2414: -- Call user hook for BEFORE

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

2407: '_PUB',
2408: x_return_status);
2409: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2410: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2411: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2412: raise OKC_API.G_EXCEPTION_ERROR;
2413: END IF;
2414: -- Call user hook for BEFORE
2415: g_sacv_rec := l_sacv_rec;

Line 2412: raise OKC_API.G_EXCEPTION_ERROR;

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

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

2413: END IF;
2414: -- Call user hook for BEFORE
2415: g_sacv_rec := l_sacv_rec;
2416: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
2417: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2418: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2419: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2420: raise OKC_API.G_EXCEPTION_ERROR;
2421: END IF;

Line 2418: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2414: -- Call user hook for BEFORE
2415: g_sacv_rec := l_sacv_rec;
2416: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
2417: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2418: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2419: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2420: raise OKC_API.G_EXCEPTION_ERROR;
2421: END IF;
2422: l_sacv_rec := migrate_sacv(l_sacv_rec, g_sacv_rec);

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

2415: g_sacv_rec := l_sacv_rec;
2416: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
2417: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2418: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2419: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2420: raise OKC_API.G_EXCEPTION_ERROR;
2421: END IF;
2422: l_sacv_rec := migrate_sacv(l_sacv_rec, g_sacv_rec);
2423:

Line 2420: raise OKC_API.G_EXCEPTION_ERROR;

2416: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
2417: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2418: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2419: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2420: raise OKC_API.G_EXCEPTION_ERROR;
2421: END IF;
2422: l_sacv_rec := migrate_sacv(l_sacv_rec, g_sacv_rec);
2423:
2424: OKC_STD_ARTICLE_PVT.create_std_art_classing(

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

2429: x_msg_data => x_msg_data,
2430: p_sacv_rec => l_sacv_rec,
2431: x_sacv_rec => x_sacv_rec);
2432:
2433: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2434: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2435: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2436: raise OKC_API.G_EXCEPTION_ERROR;
2437: END IF;

Line 2434: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2430: p_sacv_rec => l_sacv_rec,
2431: x_sacv_rec => x_sacv_rec);
2432:
2433: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2434: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2435: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2436: raise OKC_API.G_EXCEPTION_ERROR;
2437: END IF;
2438:

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

2431: x_sacv_rec => x_sacv_rec);
2432:
2433: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2434: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2435: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2436: raise OKC_API.G_EXCEPTION_ERROR;
2437: END IF;
2438:
2439: -- Call user hook for AFTER

Line 2436: raise OKC_API.G_EXCEPTION_ERROR;

2432:
2433: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2434: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2435: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2436: raise OKC_API.G_EXCEPTION_ERROR;
2437: END IF;
2438:
2439: -- Call user hook for AFTER
2440: g_sacv_rec := x_sacv_rec;

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

2438:
2439: -- Call user hook for AFTER
2440: g_sacv_rec := x_sacv_rec;
2441: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
2442: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2443: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2444: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2445: raise OKC_API.G_EXCEPTION_ERROR;
2446: END IF;

Line 2443: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2439: -- Call user hook for AFTER
2440: g_sacv_rec := x_sacv_rec;
2441: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
2442: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2443: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2444: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2445: raise OKC_API.G_EXCEPTION_ERROR;
2446: END IF;
2447: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

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

2440: g_sacv_rec := x_sacv_rec;
2441: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
2442: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2443: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2444: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2445: raise OKC_API.G_EXCEPTION_ERROR;
2446: END IF;
2447: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
2448: EXCEPTION

Line 2445: raise OKC_API.G_EXCEPTION_ERROR;

2441: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
2442: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2443: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2444: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2445: raise OKC_API.G_EXCEPTION_ERROR;
2446: END IF;
2447: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
2448: EXCEPTION
2449: WHEN OKC_API.G_EXCEPTION_ERROR THEN

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

2443: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2444: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2445: raise OKC_API.G_EXCEPTION_ERROR;
2446: END IF;
2447: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
2448: EXCEPTION
2449: WHEN OKC_API.G_EXCEPTION_ERROR THEN
2450: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2451: (l_api_name,

Line 2449: WHEN OKC_API.G_EXCEPTION_ERROR THEN

2445: raise OKC_API.G_EXCEPTION_ERROR;
2446: END IF;
2447: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
2448: EXCEPTION
2449: WHEN OKC_API.G_EXCEPTION_ERROR THEN
2450: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2451: (l_api_name,
2452: G_PKG_NAME,
2453: 'OKC_API.G_RET_STS_ERROR',

Line 2450: x_return_status := OKC_API.HANDLE_EXCEPTIONS

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

Line 2453: 'OKC_API.G_RET_STS_ERROR',

2449: WHEN OKC_API.G_EXCEPTION_ERROR THEN
2450: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2451: (l_api_name,
2452: G_PKG_NAME,
2453: 'OKC_API.G_RET_STS_ERROR',
2454: x_msg_count,
2455: x_msg_data,
2456: '_PUB');
2457: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

Line 2457: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

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

Line 2458: x_return_status := OKC_API.HANDLE_EXCEPTIONS

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

Line 2461: 'OKC_API.G_RET_STS_UNEXP_ERROR',

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

Line 2466: x_return_status := OKC_API.HANDLE_EXCEPTIONS

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

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

2480: x_msg_data OUT NOCOPY VARCHAR2,
2481: p_sacv_tbl IN sacv_tbl_type,
2482: x_sacv_tbl OUT NOCOPY sacv_tbl_type) IS
2483: i NUMBER := 0;
2484: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2485:
2486: BEGIN
2487: x_return_status := OKC_API.G_RET_STS_SUCCESS;
2488: IF p_sacv_tbl.COUNT > 0 THEN

Line 2487: x_return_status := OKC_API.G_RET_STS_SUCCESS;

2483: i NUMBER := 0;
2484: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2485:
2486: BEGIN
2487: x_return_status := OKC_API.G_RET_STS_SUCCESS;
2488: IF p_sacv_tbl.COUNT > 0 THEN
2489: i := p_sacv_tbl.FIRST;
2490: LOOP
2491: create_std_art_classing(

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

2495: x_msg_count => x_msg_count,
2496: x_msg_data => x_msg_data,
2497: p_sacv_rec => p_sacv_tbl(i),
2498: x_sacv_rec => x_sacv_tbl(i));
2499: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2500: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2501: x_return_status := l_return_status;
2502: raise G_EXCEPTION_HALT_PROCESSING;
2503: ELSE

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

2496: x_msg_data => x_msg_data,
2497: p_sacv_rec => p_sacv_tbl(i),
2498: x_sacv_rec => x_sacv_tbl(i));
2499: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2500: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2501: x_return_status := l_return_status;
2502: raise G_EXCEPTION_HALT_PROCESSING;
2503: ELSE
2504: x_return_status := l_return_status;

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

2511: EXCEPTION
2512: WHEN G_EXCEPTION_HALT_PROCESSING THEN
2513: NULL;
2514: WHEN OTHERS THEN
2515: OKC_API.set_message(p_app_name => g_app_name,
2516: p_msg_name => g_unexpected_error,
2517: p_token1 => g_sqlcode_token,
2518: p_token1_value => sqlcode,
2519: p_token2 => g_sqlerrm_token,

Line 2521: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

2517: p_token1 => g_sqlcode_token,
2518: p_token1_value => sqlcode,
2519: p_token2 => g_sqlerrm_token,
2520: p_token2_value => sqlerrm);
2521: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
2522: END create_std_art_classing;
2523:
2524: PROCEDURE update_std_art_classing(
2525: p_api_version IN NUMBER,

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

2528: x_msg_count OUT NOCOPY NUMBER,
2529: x_msg_data OUT NOCOPY VARCHAR2,
2530: p_sacv_rec IN sacv_rec_type,
2531: x_sacv_rec OUT NOCOPY sacv_rec_type) IS
2532: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2533: l_api_name CONSTANT VARCHAR2(30) := 'UPDATE_STD_ART_CLASSING';
2534: l_sacv_rec sacv_rec_type := p_sacv_rec;
2535: BEGIN
2536: l_return_status := OKC_API.START_ACTIVITY(l_api_name,

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

2532: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2533: l_api_name CONSTANT VARCHAR2(30) := 'UPDATE_STD_ART_CLASSING';
2534: l_sacv_rec sacv_rec_type := p_sacv_rec;
2535: BEGIN
2536: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
2537: p_init_msg_list,
2538: '_PUB',
2539: x_return_status);
2540: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

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

2536: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
2537: p_init_msg_list,
2538: '_PUB',
2539: x_return_status);
2540: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2541: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2542: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2543: raise OKC_API.G_EXCEPTION_ERROR;
2544: END IF;

Line 2541: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2537: p_init_msg_list,
2538: '_PUB',
2539: x_return_status);
2540: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2541: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2542: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2543: raise OKC_API.G_EXCEPTION_ERROR;
2544: END IF;
2545: -- Call user hook for BEFORE

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

2538: '_PUB',
2539: x_return_status);
2540: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2541: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2542: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2543: raise OKC_API.G_EXCEPTION_ERROR;
2544: END IF;
2545: -- Call user hook for BEFORE
2546: g_sacv_rec := l_sacv_rec;

Line 2543: raise OKC_API.G_EXCEPTION_ERROR;

2539: x_return_status);
2540: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2541: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2542: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2543: raise OKC_API.G_EXCEPTION_ERROR;
2544: END IF;
2545: -- Call user hook for BEFORE
2546: g_sacv_rec := l_sacv_rec;
2547: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');

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

2544: END IF;
2545: -- Call user hook for BEFORE
2546: g_sacv_rec := l_sacv_rec;
2547: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
2548: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2549: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2550: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2551: raise OKC_API.G_EXCEPTION_ERROR;
2552: END IF;

Line 2549: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2545: -- Call user hook for BEFORE
2546: g_sacv_rec := l_sacv_rec;
2547: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
2548: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2549: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2550: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2551: raise OKC_API.G_EXCEPTION_ERROR;
2552: END IF;
2553: l_sacv_rec := migrate_sacv(l_sacv_rec, g_sacv_rec);

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

2546: g_sacv_rec := l_sacv_rec;
2547: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
2548: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2549: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2550: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2551: raise OKC_API.G_EXCEPTION_ERROR;
2552: END IF;
2553: l_sacv_rec := migrate_sacv(l_sacv_rec, g_sacv_rec);
2554:

Line 2551: raise OKC_API.G_EXCEPTION_ERROR;

2547: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
2548: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2549: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2550: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2551: raise OKC_API.G_EXCEPTION_ERROR;
2552: END IF;
2553: l_sacv_rec := migrate_sacv(l_sacv_rec, g_sacv_rec);
2554:
2555: OKC_STD_ARTICLE_PVT.update_std_art_classing(

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

2560: x_msg_data => x_msg_data,
2561: p_sacv_rec => l_sacv_rec,
2562: x_sacv_rec => x_sacv_rec);
2563:
2564: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2565: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2566: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2567: raise OKC_API.G_EXCEPTION_ERROR;
2568: END IF;

Line 2565: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2561: p_sacv_rec => l_sacv_rec,
2562: x_sacv_rec => x_sacv_rec);
2563:
2564: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2565: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2566: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2567: raise OKC_API.G_EXCEPTION_ERROR;
2568: END IF;
2569:

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

2562: x_sacv_rec => x_sacv_rec);
2563:
2564: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2565: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2566: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2567: raise OKC_API.G_EXCEPTION_ERROR;
2568: END IF;
2569:
2570: -- Call user hook for AFTER

Line 2567: raise OKC_API.G_EXCEPTION_ERROR;

2563:
2564: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2565: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2566: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2567: raise OKC_API.G_EXCEPTION_ERROR;
2568: END IF;
2569:
2570: -- Call user hook for AFTER
2571: g_sacv_rec := x_sacv_rec;

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

2569:
2570: -- Call user hook for AFTER
2571: g_sacv_rec := x_sacv_rec;
2572: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
2573: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2574: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2575: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2576: raise OKC_API.G_EXCEPTION_ERROR;
2577: END IF;

Line 2574: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2570: -- Call user hook for AFTER
2571: g_sacv_rec := x_sacv_rec;
2572: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
2573: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2574: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2575: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2576: raise OKC_API.G_EXCEPTION_ERROR;
2577: END IF;
2578: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

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

2571: g_sacv_rec := x_sacv_rec;
2572: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
2573: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2574: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2575: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2576: raise OKC_API.G_EXCEPTION_ERROR;
2577: END IF;
2578: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
2579: EXCEPTION

Line 2576: raise OKC_API.G_EXCEPTION_ERROR;

2572: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
2573: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2574: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2575: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2576: raise OKC_API.G_EXCEPTION_ERROR;
2577: END IF;
2578: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
2579: EXCEPTION
2580: WHEN OKC_API.G_EXCEPTION_ERROR THEN

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

2574: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2575: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2576: raise OKC_API.G_EXCEPTION_ERROR;
2577: END IF;
2578: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
2579: EXCEPTION
2580: WHEN OKC_API.G_EXCEPTION_ERROR THEN
2581: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2582: (l_api_name,

Line 2580: WHEN OKC_API.G_EXCEPTION_ERROR THEN

2576: raise OKC_API.G_EXCEPTION_ERROR;
2577: END IF;
2578: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
2579: EXCEPTION
2580: WHEN OKC_API.G_EXCEPTION_ERROR THEN
2581: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2582: (l_api_name,
2583: G_PKG_NAME,
2584: 'OKC_API.G_RET_STS_ERROR',

Line 2581: x_return_status := OKC_API.HANDLE_EXCEPTIONS

2577: END IF;
2578: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
2579: EXCEPTION
2580: WHEN OKC_API.G_EXCEPTION_ERROR THEN
2581: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2582: (l_api_name,
2583: G_PKG_NAME,
2584: 'OKC_API.G_RET_STS_ERROR',
2585: x_msg_count,

Line 2584: 'OKC_API.G_RET_STS_ERROR',

2580: WHEN OKC_API.G_EXCEPTION_ERROR THEN
2581: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2582: (l_api_name,
2583: G_PKG_NAME,
2584: 'OKC_API.G_RET_STS_ERROR',
2585: x_msg_count,
2586: x_msg_data,
2587: '_PUB');
2588: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

Line 2588: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

2584: 'OKC_API.G_RET_STS_ERROR',
2585: x_msg_count,
2586: x_msg_data,
2587: '_PUB');
2588: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
2589: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2590: (l_api_name,
2591: G_PKG_NAME,
2592: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 2589: x_return_status := OKC_API.HANDLE_EXCEPTIONS

2585: x_msg_count,
2586: x_msg_data,
2587: '_PUB');
2588: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
2589: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2590: (l_api_name,
2591: G_PKG_NAME,
2592: 'OKC_API.G_RET_STS_UNEXP_ERROR',
2593: x_msg_count,

Line 2592: 'OKC_API.G_RET_STS_UNEXP_ERROR',

2588: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
2589: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2590: (l_api_name,
2591: G_PKG_NAME,
2592: 'OKC_API.G_RET_STS_UNEXP_ERROR',
2593: x_msg_count,
2594: x_msg_data,
2595: '_PUB');
2596: WHEN OTHERS THEN

Line 2597: x_return_status := OKC_API.HANDLE_EXCEPTIONS

2593: x_msg_count,
2594: x_msg_data,
2595: '_PUB');
2596: WHEN OTHERS THEN
2597: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2598: (l_api_name,
2599: G_PKG_NAME,
2600: 'OTHERS',
2601: x_msg_count,

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

2613: x_msg_data OUT NOCOPY VARCHAR2,
2614: p_sacv_tbl IN sacv_tbl_type,
2615: x_sacv_tbl OUT NOCOPY sacv_tbl_type) IS
2616: i NUMBER := 0;
2617: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2618:
2619: BEGIN
2620: x_return_status := OKC_API.G_RET_STS_SUCCESS;
2621: IF p_sacv_tbl.COUNT > 0 THEN

Line 2620: x_return_status := OKC_API.G_RET_STS_SUCCESS;

2616: i NUMBER := 0;
2617: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2618:
2619: BEGIN
2620: x_return_status := OKC_API.G_RET_STS_SUCCESS;
2621: IF p_sacv_tbl.COUNT > 0 THEN
2622: i := p_sacv_tbl.FIRST;
2623: LOOP
2624: update_std_art_classing(

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

2628: x_msg_count => x_msg_count,
2629: x_msg_data => x_msg_data,
2630: p_sacv_rec => p_sacv_tbl(i),
2631: x_sacv_rec => x_sacv_tbl(i));
2632: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2633: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2634: x_return_status := l_return_status;
2635: raise G_EXCEPTION_HALT_PROCESSING;
2636: ELSE

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

2629: x_msg_data => x_msg_data,
2630: p_sacv_rec => p_sacv_tbl(i),
2631: x_sacv_rec => x_sacv_tbl(i));
2632: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2633: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2634: x_return_status := l_return_status;
2635: raise G_EXCEPTION_HALT_PROCESSING;
2636: ELSE
2637: x_return_status := l_return_status;

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

2644: EXCEPTION
2645: WHEN G_EXCEPTION_HALT_PROCESSING THEN
2646: NULL;
2647: WHEN OTHERS THEN
2648: OKC_API.set_message(p_app_name => g_app_name,
2649: p_msg_name => g_unexpected_error,
2650: p_token1 => g_sqlcode_token,
2651: p_token1_value => sqlcode,
2652: p_token2 => g_sqlerrm_token,

Line 2654: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

2650: p_token1 => g_sqlcode_token,
2651: p_token1_value => sqlcode,
2652: p_token2 => g_sqlerrm_token,
2653: p_token2_value => sqlerrm);
2654: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
2655: END update_std_art_classing;
2656:
2657:
2658: PROCEDURE lock_std_art_classing(

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

2680: x_msg_count OUT NOCOPY NUMBER,
2681: x_msg_data OUT NOCOPY VARCHAR2,
2682: p_sacv_tbl IN sacv_tbl_type)IS
2683: i NUMBER := 0;
2684: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2685:
2686: BEGIN
2687: x_return_status := OKC_API.G_RET_STS_SUCCESS;
2688: IF p_sacv_tbl.COUNT > 0 THEN

Line 2687: x_return_status := OKC_API.G_RET_STS_SUCCESS;

2683: i NUMBER := 0;
2684: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2685:
2686: BEGIN
2687: x_return_status := OKC_API.G_RET_STS_SUCCESS;
2688: IF p_sacv_tbl.COUNT > 0 THEN
2689: i := p_sacv_tbl.FIRST;
2690: LOOP
2691: lock_std_art_classing(

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

2694: x_return_status => l_return_status,
2695: x_msg_count => x_msg_count,
2696: x_msg_data => x_msg_data,
2697: p_sacv_rec => p_sacv_tbl(i));
2698: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2699: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2700: x_return_status := l_return_status;
2701: raise G_EXCEPTION_HALT_PROCESSING;
2702: ELSE

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

2695: x_msg_count => x_msg_count,
2696: x_msg_data => x_msg_data,
2697: p_sacv_rec => p_sacv_tbl(i));
2698: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2699: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2700: x_return_status := l_return_status;
2701: raise G_EXCEPTION_HALT_PROCESSING;
2702: ELSE
2703: x_return_status := l_return_status;

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

2710: EXCEPTION
2711: WHEN G_EXCEPTION_HALT_PROCESSING THEN
2712: NULL;
2713: WHEN OTHERS THEN
2714: OKC_API.set_message(p_app_name => g_app_name,
2715: p_msg_name => g_unexpected_error,
2716: p_token1 => g_sqlcode_token,
2717: p_token1_value => sqlcode,
2718: p_token2 => g_sqlerrm_token,

Line 2720: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

2716: p_token1 => g_sqlcode_token,
2717: p_token1_value => sqlcode,
2718: p_token2 => g_sqlerrm_token,
2719: p_token2_value => sqlerrm);
2720: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
2721: END lock_std_art_classing;
2722:
2723:
2724: PROCEDURE delete_std_art_classing(

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

2727: x_return_status OUT NOCOPY VARCHAR2,
2728: x_msg_count OUT NOCOPY NUMBER,
2729: x_msg_data OUT NOCOPY VARCHAR2,
2730: p_sacv_rec IN sacv_rec_type) IS
2731: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2732: l_api_name CONSTANT VARCHAR2(30) := 'DELETE_STD_ART_CLASSING';
2733: l_sacv_rec sacv_rec_type := p_sacv_rec;
2734: BEGIN
2735: l_return_status := OKC_API.START_ACTIVITY(l_api_name,

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

2731: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2732: l_api_name CONSTANT VARCHAR2(30) := 'DELETE_STD_ART_CLASSING';
2733: l_sacv_rec sacv_rec_type := p_sacv_rec;
2734: BEGIN
2735: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
2736: p_init_msg_list,
2737: '_PUB',
2738: x_return_status);
2739: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

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

2735: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
2736: p_init_msg_list,
2737: '_PUB',
2738: x_return_status);
2739: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2740: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2741: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2742: raise OKC_API.G_EXCEPTION_ERROR;
2743: END IF;

Line 2740: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2736: p_init_msg_list,
2737: '_PUB',
2738: x_return_status);
2739: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2740: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2741: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2742: raise OKC_API.G_EXCEPTION_ERROR;
2743: END IF;
2744: -- Call user hook for BEFORE

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

2737: '_PUB',
2738: x_return_status);
2739: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2740: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2741: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2742: raise OKC_API.G_EXCEPTION_ERROR;
2743: END IF;
2744: -- Call user hook for BEFORE
2745: g_sacv_rec := l_sacv_rec;

Line 2742: raise OKC_API.G_EXCEPTION_ERROR;

2738: x_return_status);
2739: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2740: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2741: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2742: raise OKC_API.G_EXCEPTION_ERROR;
2743: END IF;
2744: -- Call user hook for BEFORE
2745: g_sacv_rec := l_sacv_rec;
2746: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');

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

2743: END IF;
2744: -- Call user hook for BEFORE
2745: g_sacv_rec := l_sacv_rec;
2746: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
2747: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2748: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2749: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2750: raise OKC_API.G_EXCEPTION_ERROR;
2751: END IF;

Line 2748: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2744: -- Call user hook for BEFORE
2745: g_sacv_rec := l_sacv_rec;
2746: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
2747: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2748: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2749: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2750: raise OKC_API.G_EXCEPTION_ERROR;
2751: END IF;
2752: l_sacv_rec := migrate_sacv(l_sacv_rec, g_sacv_rec);

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

2745: g_sacv_rec := l_sacv_rec;
2746: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
2747: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2748: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2749: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2750: raise OKC_API.G_EXCEPTION_ERROR;
2751: END IF;
2752: l_sacv_rec := migrate_sacv(l_sacv_rec, g_sacv_rec);
2753:

Line 2750: raise OKC_API.G_EXCEPTION_ERROR;

2746: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
2747: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2748: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2749: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2750: raise OKC_API.G_EXCEPTION_ERROR;
2751: END IF;
2752: l_sacv_rec := migrate_sacv(l_sacv_rec, g_sacv_rec);
2753:
2754: OKC_STD_ARTICLE_PVT.delete_std_art_classing(

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

2758: x_msg_count => x_msg_count,
2759: x_msg_data => x_msg_data,
2760: p_sacv_rec => l_sacv_rec);
2761:
2762: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2763: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2764: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2765: raise OKC_API.G_EXCEPTION_ERROR;
2766: END IF;

Line 2763: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2759: x_msg_data => x_msg_data,
2760: p_sacv_rec => l_sacv_rec);
2761:
2762: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2763: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2764: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2765: raise OKC_API.G_EXCEPTION_ERROR;
2766: END IF;
2767:

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

2760: p_sacv_rec => l_sacv_rec);
2761:
2762: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2763: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2764: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2765: raise OKC_API.G_EXCEPTION_ERROR;
2766: END IF;
2767:
2768: -- Call user hook for AFTER

Line 2765: raise OKC_API.G_EXCEPTION_ERROR;

2761:
2762: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2763: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2764: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2765: raise OKC_API.G_EXCEPTION_ERROR;
2766: END IF;
2767:
2768: -- Call user hook for AFTER
2769: g_sacv_rec := l_sacv_rec;

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

2767:
2768: -- Call user hook for AFTER
2769: g_sacv_rec := l_sacv_rec;
2770: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
2771: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2772: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2773: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2774: raise OKC_API.G_EXCEPTION_ERROR;
2775: END IF;

Line 2772: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2768: -- Call user hook for AFTER
2769: g_sacv_rec := l_sacv_rec;
2770: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
2771: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2772: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2773: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2774: raise OKC_API.G_EXCEPTION_ERROR;
2775: END IF;
2776: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

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

2769: g_sacv_rec := l_sacv_rec;
2770: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
2771: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2772: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2773: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2774: raise OKC_API.G_EXCEPTION_ERROR;
2775: END IF;
2776: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
2777: EXCEPTION

Line 2774: raise OKC_API.G_EXCEPTION_ERROR;

2770: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
2771: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2772: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2773: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2774: raise OKC_API.G_EXCEPTION_ERROR;
2775: END IF;
2776: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
2777: EXCEPTION
2778: WHEN OKC_API.G_EXCEPTION_ERROR THEN

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

2772: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2773: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2774: raise OKC_API.G_EXCEPTION_ERROR;
2775: END IF;
2776: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
2777: EXCEPTION
2778: WHEN OKC_API.G_EXCEPTION_ERROR THEN
2779: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2780: (l_api_name,

Line 2778: WHEN OKC_API.G_EXCEPTION_ERROR THEN

2774: raise OKC_API.G_EXCEPTION_ERROR;
2775: END IF;
2776: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
2777: EXCEPTION
2778: WHEN OKC_API.G_EXCEPTION_ERROR THEN
2779: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2780: (l_api_name,
2781: G_PKG_NAME,
2782: 'OKC_API.G_RET_STS_ERROR',

Line 2779: x_return_status := OKC_API.HANDLE_EXCEPTIONS

2775: END IF;
2776: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
2777: EXCEPTION
2778: WHEN OKC_API.G_EXCEPTION_ERROR THEN
2779: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2780: (l_api_name,
2781: G_PKG_NAME,
2782: 'OKC_API.G_RET_STS_ERROR',
2783: x_msg_count,

Line 2782: 'OKC_API.G_RET_STS_ERROR',

2778: WHEN OKC_API.G_EXCEPTION_ERROR THEN
2779: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2780: (l_api_name,
2781: G_PKG_NAME,
2782: 'OKC_API.G_RET_STS_ERROR',
2783: x_msg_count,
2784: x_msg_data,
2785: '_PUB');
2786: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

Line 2786: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

2782: 'OKC_API.G_RET_STS_ERROR',
2783: x_msg_count,
2784: x_msg_data,
2785: '_PUB');
2786: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
2787: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2788: (l_api_name,
2789: G_PKG_NAME,
2790: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 2787: x_return_status := OKC_API.HANDLE_EXCEPTIONS

2783: x_msg_count,
2784: x_msg_data,
2785: '_PUB');
2786: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
2787: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2788: (l_api_name,
2789: G_PKG_NAME,
2790: 'OKC_API.G_RET_STS_UNEXP_ERROR',
2791: x_msg_count,

Line 2790: 'OKC_API.G_RET_STS_UNEXP_ERROR',

2786: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
2787: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2788: (l_api_name,
2789: G_PKG_NAME,
2790: 'OKC_API.G_RET_STS_UNEXP_ERROR',
2791: x_msg_count,
2792: x_msg_data,
2793: '_PUB');
2794: WHEN OTHERS THEN

Line 2795: x_return_status := OKC_API.HANDLE_EXCEPTIONS

2791: x_msg_count,
2792: x_msg_data,
2793: '_PUB');
2794: WHEN OTHERS THEN
2795: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2796: (l_api_name,
2797: G_PKG_NAME,
2798: 'OTHERS',
2799: x_msg_count,

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

2808: x_msg_count OUT NOCOPY NUMBER,
2809: x_msg_data OUT NOCOPY VARCHAR2,
2810: p_sacv_tbl IN sacv_tbl_type) IS
2811: i NUMBER := 0;
2812: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2813:
2814: BEGIN
2815: x_return_status := OKC_API.G_RET_STS_SUCCESS;
2816: IF p_sacv_tbl.COUNT > 0 THEN

Line 2815: x_return_status := OKC_API.G_RET_STS_SUCCESS;

2811: i NUMBER := 0;
2812: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2813:
2814: BEGIN
2815: x_return_status := OKC_API.G_RET_STS_SUCCESS;
2816: IF p_sacv_tbl.COUNT > 0 THEN
2817: i := p_sacv_tbl.FIRST;
2818: LOOP
2819: delete_std_art_classing(

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

2822: x_return_status => l_return_status,
2823: x_msg_count => x_msg_count,
2824: x_msg_data => x_msg_data,
2825: p_sacv_rec => p_sacv_tbl(i));
2826: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2827: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2828: x_return_status := l_return_status;
2829: raise G_EXCEPTION_HALT_PROCESSING;
2830: ELSE

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

2823: x_msg_count => x_msg_count,
2824: x_msg_data => x_msg_data,
2825: p_sacv_rec => p_sacv_tbl(i));
2826: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2827: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2828: x_return_status := l_return_status;
2829: raise G_EXCEPTION_HALT_PROCESSING;
2830: ELSE
2831: x_return_status := l_return_status;

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

2838: EXCEPTION
2839: WHEN G_EXCEPTION_HALT_PROCESSING THEN
2840: NULL;
2841: WHEN OTHERS THEN
2842: OKC_API.set_message(p_app_name => g_app_name,
2843: p_msg_name => g_unexpected_error,
2844: p_token1 => g_sqlcode_token,
2845: p_token1_value => sqlcode,
2846: p_token2 => g_sqlerrm_token,

Line 2848: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

2844: p_token1 => g_sqlcode_token,
2845: p_token1_value => sqlcode,
2846: p_token2 => g_sqlerrm_token,
2847: p_token2_value => sqlerrm);
2848: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
2849: END delete_std_art_classing;
2850:
2851:
2852: PROCEDURE validate_std_art_classing(

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

2875: x_msg_count OUT NOCOPY NUMBER,
2876: x_msg_data OUT NOCOPY VARCHAR2,
2877: p_sacv_tbl IN sacv_tbl_type) IS
2878: i NUMBER := 0;
2879: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2880:
2881: BEGIN
2882: x_return_status := OKC_API.G_RET_STS_SUCCESS;
2883: IF p_sacv_tbl.COUNT > 0 THEN

Line 2882: x_return_status := OKC_API.G_RET_STS_SUCCESS;

2878: i NUMBER := 0;
2879: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2880:
2881: BEGIN
2882: x_return_status := OKC_API.G_RET_STS_SUCCESS;
2883: IF p_sacv_tbl.COUNT > 0 THEN
2884: i := p_sacv_tbl.FIRST;
2885: LOOP
2886: validate_std_art_classing(

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

2889: x_return_status => l_return_status,
2890: x_msg_count => x_msg_count,
2891: x_msg_data => x_msg_data,
2892: p_sacv_rec => p_sacv_tbl(i));
2893: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2894: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2895: x_return_status := l_return_status;
2896: raise G_EXCEPTION_HALT_PROCESSING;
2897: ELSE

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

2890: x_msg_count => x_msg_count,
2891: x_msg_data => x_msg_data,
2892: p_sacv_rec => p_sacv_tbl(i));
2893: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2894: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2895: x_return_status := l_return_status;
2896: raise G_EXCEPTION_HALT_PROCESSING;
2897: ELSE
2898: x_return_status := l_return_status;

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

2905: EXCEPTION
2906: WHEN G_EXCEPTION_HALT_PROCESSING THEN
2907: NULL;
2908: WHEN OTHERS THEN
2909: OKC_API.set_message(p_app_name => g_app_name,
2910: p_msg_name => g_unexpected_error,
2911: p_token1 => g_sqlcode_token,
2912: p_token1_value => sqlcode,
2913: p_token2 => g_sqlerrm_token,

Line 2915: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

2911: p_token1 => g_sqlcode_token,
2912: p_token1_value => sqlcode,
2913: p_token2 => g_sqlerrm_token,
2914: p_token2_value => sqlerrm);
2915: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
2916: END validate_std_art_classing;
2917:
2918: PROCEDURE validate_price_type(
2919: p_api_version IN NUMBER,

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

2940: x_msg_data OUT NOCOPY VARCHAR2,
2941: p_sacv_tbl IN sacv_tbl_type) IS
2942:
2943: i NUMBER := 0;
2944: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2945:
2946: BEGIN
2947: x_return_status := OKC_API.G_RET_STS_SUCCESS;
2948: IF p_sacv_tbl.COUNT > 0 THEN

Line 2947: x_return_status := OKC_API.G_RET_STS_SUCCESS;

2943: i NUMBER := 0;
2944: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2945:
2946: BEGIN
2947: x_return_status := OKC_API.G_RET_STS_SUCCESS;
2948: IF p_sacv_tbl.COUNT > 0 THEN
2949: i := p_sacv_tbl.FIRST;
2950: LOOP
2951: Validate_price_type(p_api_version => p_api_version,

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

2954: x_msg_count => x_msg_count,
2955: x_msg_data => x_msg_data,
2956: p_sacv_rec => p_sacv_tbl(i));
2957:
2958: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2959: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2960: x_return_status := l_return_status;
2961: raise G_EXCEPTION_HALT_PROCESSING;
2962: ELSE

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

2955: x_msg_data => x_msg_data,
2956: p_sacv_rec => p_sacv_tbl(i));
2957:
2958: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2959: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2960: x_return_status := l_return_status;
2961: raise G_EXCEPTION_HALT_PROCESSING;
2962: ELSE
2963: x_return_status := l_return_status;

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

2970: EXCEPTION
2971: WHEN G_EXCEPTION_HALT_PROCESSING THEN
2972: NULL;
2973: WHEN OTHERS THEN
2974: OKC_API.set_message(p_app_name => g_app_name,
2975: p_msg_name => g_unexpected_error,
2976: p_token1 => g_sqlcode_token,
2977: p_token1_value => sqlcode,
2978: p_token2 => g_sqlerrm_token,

Line 2980: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

2976: p_token1 => g_sqlcode_token,
2977: p_token1_value => sqlcode,
2978: p_token2 => g_sqlerrm_token,
2979: p_token2_value => sqlerrm);
2980: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
2981: End Validate_price_type;
2982:
2983: PROCEDURE validate_scs_code(
2984: p_api_version IN NUMBER,

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

3005: x_msg_data OUT NOCOPY VARCHAR2,
3006: p_sacv_tbl IN sacv_tbl_type) IS
3007:
3008: i NUMBER := 0;
3009: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
3010:
3011: BEGIN
3012: x_return_status := OKC_API.G_RET_STS_SUCCESS;
3013: IF p_sacv_tbl.COUNT > 0 THEN

Line 3012: x_return_status := OKC_API.G_RET_STS_SUCCESS;

3008: i NUMBER := 0;
3009: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
3010:
3011: BEGIN
3012: x_return_status := OKC_API.G_RET_STS_SUCCESS;
3013: IF p_sacv_tbl.COUNT > 0 THEN
3014: i := p_sacv_tbl.FIRST;
3015: LOOP
3016: Validate_scs_code(p_api_version => p_api_version,

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

3019: x_msg_count => x_msg_count,
3020: x_msg_data => x_msg_data,
3021: p_sacv_rec => p_sacv_tbl(i));
3022:
3023: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
3024: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3025: x_return_status := l_return_status;
3026: raise G_EXCEPTION_HALT_PROCESSING;
3027: ELSE

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

3020: x_msg_data => x_msg_data,
3021: p_sacv_rec => p_sacv_tbl(i));
3022:
3023: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
3024: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3025: x_return_status := l_return_status;
3026: raise G_EXCEPTION_HALT_PROCESSING;
3027: ELSE
3028: x_return_status := l_return_status;

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

3035: EXCEPTION
3036: WHEN G_EXCEPTION_HALT_PROCESSING THEN
3037: NULL;
3038: WHEN OTHERS THEN
3039: OKC_API.set_message(p_app_name => g_app_name,
3040: p_msg_name => g_unexpected_error,
3041: p_token1 => g_sqlcode_token,
3042: p_token1_value => sqlcode,
3043: p_token2 => g_sqlerrm_token,

Line 3045: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

3041: p_token1 => g_sqlcode_token,
3042: p_token1_value => sqlcode,
3043: p_token2 => g_sqlerrm_token,
3044: p_token2_value => sqlerrm);
3045: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
3046: End Validate_scs_code;
3047:
3048: PROCEDURE create_std_art_set_mem(
3049: p_api_version IN NUMBER,

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

3052: x_msg_count OUT NOCOPY NUMBER,
3053: x_msg_data OUT NOCOPY VARCHAR2,
3054: p_samv_rec IN samv_rec_type,
3055: x_samv_rec OUT NOCOPY samv_rec_type) IS
3056: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
3057: l_api_name CONSTANT VARCHAR2(30) := 'CREATE_STD_ART_SET_MEM';
3058: l_samv_rec samv_rec_type := p_samv_rec;
3059: BEGIN
3060: l_return_status := OKC_API.START_ACTIVITY(l_api_name,

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

3056: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
3057: l_api_name CONSTANT VARCHAR2(30) := 'CREATE_STD_ART_SET_MEM';
3058: l_samv_rec samv_rec_type := p_samv_rec;
3059: BEGIN
3060: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
3061: p_init_msg_list,
3062: '_PUB',
3063: x_return_status);
3064: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

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

3060: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
3061: p_init_msg_list,
3062: '_PUB',
3063: x_return_status);
3064: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3065: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3066: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
3067: raise OKC_API.G_EXCEPTION_ERROR;
3068: END IF;

Line 3065: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

3061: p_init_msg_list,
3062: '_PUB',
3063: x_return_status);
3064: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3065: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3066: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
3067: raise OKC_API.G_EXCEPTION_ERROR;
3068: END IF;
3069: -- Call user hook for BEFORE

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

3062: '_PUB',
3063: x_return_status);
3064: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3065: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3066: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
3067: raise OKC_API.G_EXCEPTION_ERROR;
3068: END IF;
3069: -- Call user hook for BEFORE
3070: g_samv_rec := l_samv_rec;

Line 3067: raise OKC_API.G_EXCEPTION_ERROR;

3063: x_return_status);
3064: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3065: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3066: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
3067: raise OKC_API.G_EXCEPTION_ERROR;
3068: END IF;
3069: -- Call user hook for BEFORE
3070: g_samv_rec := l_samv_rec;
3071: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');

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

3068: END IF;
3069: -- Call user hook for BEFORE
3070: g_samv_rec := l_samv_rec;
3071: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
3072: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3073: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3074: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3075: raise OKC_API.G_EXCEPTION_ERROR;
3076: END IF;

Line 3073: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

3069: -- Call user hook for BEFORE
3070: g_samv_rec := l_samv_rec;
3071: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
3072: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3073: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3074: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3075: raise OKC_API.G_EXCEPTION_ERROR;
3076: END IF;
3077: l_samv_rec := migrate_samv(l_samv_rec, g_samv_rec);

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

3070: g_samv_rec := l_samv_rec;
3071: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
3072: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3073: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3074: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3075: raise OKC_API.G_EXCEPTION_ERROR;
3076: END IF;
3077: l_samv_rec := migrate_samv(l_samv_rec, g_samv_rec);
3078:

Line 3075: raise OKC_API.G_EXCEPTION_ERROR;

3071: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
3072: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3073: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3074: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3075: raise OKC_API.G_EXCEPTION_ERROR;
3076: END IF;
3077: l_samv_rec := migrate_samv(l_samv_rec, g_samv_rec);
3078:
3079: OKC_STD_ARTICLE_PVT.create_std_art_set_mem(

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

3084: x_msg_data => x_msg_data,
3085: p_samv_rec => l_samv_rec,
3086: x_samv_rec => x_samv_rec);
3087:
3088: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3089: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3090: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3091: raise OKC_API.G_EXCEPTION_ERROR;
3092: END IF;

Line 3089: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

3085: p_samv_rec => l_samv_rec,
3086: x_samv_rec => x_samv_rec);
3087:
3088: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3089: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3090: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3091: raise OKC_API.G_EXCEPTION_ERROR;
3092: END IF;
3093:

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

3086: x_samv_rec => x_samv_rec);
3087:
3088: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3089: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3090: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3091: raise OKC_API.G_EXCEPTION_ERROR;
3092: END IF;
3093:
3094: -- Call user hook for AFTER

Line 3091: raise OKC_API.G_EXCEPTION_ERROR;

3087:
3088: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3089: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3090: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3091: raise OKC_API.G_EXCEPTION_ERROR;
3092: END IF;
3093:
3094: -- Call user hook for AFTER
3095: g_samv_rec := x_samv_rec;

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

3093:
3094: -- Call user hook for AFTER
3095: g_samv_rec := x_samv_rec;
3096: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
3097: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3098: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3099: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3100: raise OKC_API.G_EXCEPTION_ERROR;
3101: END IF;

Line 3098: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

3094: -- Call user hook for AFTER
3095: g_samv_rec := x_samv_rec;
3096: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
3097: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3098: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3099: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3100: raise OKC_API.G_EXCEPTION_ERROR;
3101: END IF;
3102: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

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

3095: g_samv_rec := x_samv_rec;
3096: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
3097: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3098: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3099: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3100: raise OKC_API.G_EXCEPTION_ERROR;
3101: END IF;
3102: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
3103: EXCEPTION

Line 3100: raise OKC_API.G_EXCEPTION_ERROR;

3096: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
3097: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3098: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3099: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3100: raise OKC_API.G_EXCEPTION_ERROR;
3101: END IF;
3102: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
3103: EXCEPTION
3104: WHEN OKC_API.G_EXCEPTION_ERROR THEN

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

3098: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3099: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3100: raise OKC_API.G_EXCEPTION_ERROR;
3101: END IF;
3102: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
3103: EXCEPTION
3104: WHEN OKC_API.G_EXCEPTION_ERROR THEN
3105: x_return_status := OKC_API.HANDLE_EXCEPTIONS
3106: (l_api_name,

Line 3104: WHEN OKC_API.G_EXCEPTION_ERROR THEN

3100: raise OKC_API.G_EXCEPTION_ERROR;
3101: END IF;
3102: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
3103: EXCEPTION
3104: WHEN OKC_API.G_EXCEPTION_ERROR THEN
3105: x_return_status := OKC_API.HANDLE_EXCEPTIONS
3106: (l_api_name,
3107: G_PKG_NAME,
3108: 'OKC_API.G_RET_STS_ERROR',

Line 3105: x_return_status := OKC_API.HANDLE_EXCEPTIONS

3101: END IF;
3102: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
3103: EXCEPTION
3104: WHEN OKC_API.G_EXCEPTION_ERROR THEN
3105: x_return_status := OKC_API.HANDLE_EXCEPTIONS
3106: (l_api_name,
3107: G_PKG_NAME,
3108: 'OKC_API.G_RET_STS_ERROR',
3109: x_msg_count,

Line 3108: 'OKC_API.G_RET_STS_ERROR',

3104: WHEN OKC_API.G_EXCEPTION_ERROR THEN
3105: x_return_status := OKC_API.HANDLE_EXCEPTIONS
3106: (l_api_name,
3107: G_PKG_NAME,
3108: 'OKC_API.G_RET_STS_ERROR',
3109: x_msg_count,
3110: x_msg_data,
3111: '_PUB');
3112: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

Line 3112: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

3108: 'OKC_API.G_RET_STS_ERROR',
3109: x_msg_count,
3110: x_msg_data,
3111: '_PUB');
3112: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
3113: x_return_status := OKC_API.HANDLE_EXCEPTIONS
3114: (l_api_name,
3115: G_PKG_NAME,
3116: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 3113: x_return_status := OKC_API.HANDLE_EXCEPTIONS

3109: x_msg_count,
3110: x_msg_data,
3111: '_PUB');
3112: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
3113: x_return_status := OKC_API.HANDLE_EXCEPTIONS
3114: (l_api_name,
3115: G_PKG_NAME,
3116: 'OKC_API.G_RET_STS_UNEXP_ERROR',
3117: x_msg_count,

Line 3116: 'OKC_API.G_RET_STS_UNEXP_ERROR',

3112: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
3113: x_return_status := OKC_API.HANDLE_EXCEPTIONS
3114: (l_api_name,
3115: G_PKG_NAME,
3116: 'OKC_API.G_RET_STS_UNEXP_ERROR',
3117: x_msg_count,
3118: x_msg_data,
3119: '_PUB');
3120: WHEN OTHERS THEN

Line 3121: x_return_status := OKC_API.HANDLE_EXCEPTIONS

3117: x_msg_count,
3118: x_msg_data,
3119: '_PUB');
3120: WHEN OTHERS THEN
3121: x_return_status := OKC_API.HANDLE_EXCEPTIONS
3122: (l_api_name,
3123: G_PKG_NAME,
3124: 'OTHERS',
3125: x_msg_count,

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

3136: x_msg_data OUT NOCOPY VARCHAR2,
3137: p_samv_tbl IN samv_tbl_type,
3138: x_samv_tbl OUT NOCOPY samv_tbl_type) IS
3139: i NUMBER := 0;
3140: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
3141:
3142: BEGIN
3143: x_return_status := OKC_API.G_RET_STS_SUCCESS;
3144: IF p_samv_tbl.COUNT > 0 THEN

Line 3143: x_return_status := OKC_API.G_RET_STS_SUCCESS;

3139: i NUMBER := 0;
3140: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
3141:
3142: BEGIN
3143: x_return_status := OKC_API.G_RET_STS_SUCCESS;
3144: IF p_samv_tbl.COUNT > 0 THEN
3145: i := p_samv_tbl.FIRST;
3146: LOOP
3147: create_std_art_set_mem(

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

3151: x_msg_count => x_msg_count,
3152: x_msg_data => x_msg_data,
3153: p_samv_rec => p_samv_tbl(i),
3154: x_samv_rec => x_samv_tbl(i));
3155: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
3156: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3157: x_return_status := l_return_status;
3158: raise G_EXCEPTION_HALT_PROCESSING;
3159: ELSE

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

3152: x_msg_data => x_msg_data,
3153: p_samv_rec => p_samv_tbl(i),
3154: x_samv_rec => x_samv_tbl(i));
3155: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
3156: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3157: x_return_status := l_return_status;
3158: raise G_EXCEPTION_HALT_PROCESSING;
3159: ELSE
3160: x_return_status := l_return_status;

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

3167: EXCEPTION
3168: WHEN G_EXCEPTION_HALT_PROCESSING THEN
3169: NULL;
3170: WHEN OTHERS THEN
3171: OKC_API.set_message(p_app_name => g_app_name,
3172: p_msg_name => g_unexpected_error,
3173: p_token1 => g_sqlcode_token,
3174: p_token1_value => sqlcode,
3175: p_token2 => g_sqlerrm_token,

Line 3177: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

3173: p_token1 => g_sqlcode_token,
3174: p_token1_value => sqlcode,
3175: p_token2 => g_sqlerrm_token,
3176: p_token2_value => sqlerrm);
3177: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
3178: END create_std_art_set_mem;
3179:
3180: PROCEDURE update_std_art_set_mem(
3181: p_api_version IN NUMBER,

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

3184: x_msg_count OUT NOCOPY NUMBER,
3185: x_msg_data OUT NOCOPY VARCHAR2,
3186: p_samv_rec IN samv_rec_type,
3187: x_samv_rec OUT NOCOPY samv_rec_type) IS
3188: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
3189: l_api_name CONSTANT VARCHAR2(30) := 'UPDATE_STD_ART_SET_MEM';
3190: l_samv_rec samv_rec_type := p_samv_rec;
3191: BEGIN
3192: l_return_status := OKC_API.START_ACTIVITY(l_api_name,

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

3188: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
3189: l_api_name CONSTANT VARCHAR2(30) := 'UPDATE_STD_ART_SET_MEM';
3190: l_samv_rec samv_rec_type := p_samv_rec;
3191: BEGIN
3192: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
3193: p_init_msg_list,
3194: '_PUB',
3195: x_return_status);
3196: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

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

3192: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
3193: p_init_msg_list,
3194: '_PUB',
3195: x_return_status);
3196: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3197: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3198: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
3199: raise OKC_API.G_EXCEPTION_ERROR;
3200: END IF;

Line 3197: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

3193: p_init_msg_list,
3194: '_PUB',
3195: x_return_status);
3196: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3197: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3198: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
3199: raise OKC_API.G_EXCEPTION_ERROR;
3200: END IF;
3201: -- Call user hook for BEFORE

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

3194: '_PUB',
3195: x_return_status);
3196: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3197: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3198: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
3199: raise OKC_API.G_EXCEPTION_ERROR;
3200: END IF;
3201: -- Call user hook for BEFORE
3202: g_samv_rec := l_samv_rec;

Line 3199: raise OKC_API.G_EXCEPTION_ERROR;

3195: x_return_status);
3196: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3197: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3198: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
3199: raise OKC_API.G_EXCEPTION_ERROR;
3200: END IF;
3201: -- Call user hook for BEFORE
3202: g_samv_rec := l_samv_rec;
3203: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');

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

3200: END IF;
3201: -- Call user hook for BEFORE
3202: g_samv_rec := l_samv_rec;
3203: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
3204: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3205: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3206: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3207: raise OKC_API.G_EXCEPTION_ERROR;
3208: END IF;

Line 3205: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

3201: -- Call user hook for BEFORE
3202: g_samv_rec := l_samv_rec;
3203: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
3204: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3205: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3206: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3207: raise OKC_API.G_EXCEPTION_ERROR;
3208: END IF;
3209: l_samv_rec := migrate_samv(l_samv_rec, g_samv_rec);

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

3202: g_samv_rec := l_samv_rec;
3203: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
3204: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3205: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3206: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3207: raise OKC_API.G_EXCEPTION_ERROR;
3208: END IF;
3209: l_samv_rec := migrate_samv(l_samv_rec, g_samv_rec);
3210:

Line 3207: raise OKC_API.G_EXCEPTION_ERROR;

3203: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
3204: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3205: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3206: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3207: raise OKC_API.G_EXCEPTION_ERROR;
3208: END IF;
3209: l_samv_rec := migrate_samv(l_samv_rec, g_samv_rec);
3210:
3211: OKC_STD_ARTICLE_PVT.update_std_art_set_mem(

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

3216: x_msg_data => x_msg_data,
3217: p_samv_rec => l_samv_rec,
3218: x_samv_rec => x_samv_rec);
3219:
3220: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3221: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3222: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3223: raise OKC_API.G_EXCEPTION_ERROR;
3224: END IF;

Line 3221: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

3217: p_samv_rec => l_samv_rec,
3218: x_samv_rec => x_samv_rec);
3219:
3220: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3221: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3222: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3223: raise OKC_API.G_EXCEPTION_ERROR;
3224: END IF;
3225:

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

3218: x_samv_rec => x_samv_rec);
3219:
3220: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3221: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3222: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3223: raise OKC_API.G_EXCEPTION_ERROR;
3224: END IF;
3225:
3226: -- Call user hook for AFTER

Line 3223: raise OKC_API.G_EXCEPTION_ERROR;

3219:
3220: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3221: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3222: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3223: raise OKC_API.G_EXCEPTION_ERROR;
3224: END IF;
3225:
3226: -- Call user hook for AFTER
3227: g_samv_rec := x_samv_rec;

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

3225:
3226: -- Call user hook for AFTER
3227: g_samv_rec := x_samv_rec;
3228: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
3229: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3230: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3231: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3232: raise OKC_API.G_EXCEPTION_ERROR;
3233: END IF;

Line 3230: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

3226: -- Call user hook for AFTER
3227: g_samv_rec := x_samv_rec;
3228: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
3229: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3230: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3231: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3232: raise OKC_API.G_EXCEPTION_ERROR;
3233: END IF;
3234: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

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

3227: g_samv_rec := x_samv_rec;
3228: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
3229: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3230: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3231: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3232: raise OKC_API.G_EXCEPTION_ERROR;
3233: END IF;
3234: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
3235: EXCEPTION

Line 3232: raise OKC_API.G_EXCEPTION_ERROR;

3228: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
3229: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3230: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3231: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3232: raise OKC_API.G_EXCEPTION_ERROR;
3233: END IF;
3234: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
3235: EXCEPTION
3236: WHEN OKC_API.G_EXCEPTION_ERROR THEN

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

3230: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3231: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3232: raise OKC_API.G_EXCEPTION_ERROR;
3233: END IF;
3234: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
3235: EXCEPTION
3236: WHEN OKC_API.G_EXCEPTION_ERROR THEN
3237: x_return_status := OKC_API.HANDLE_EXCEPTIONS
3238: (l_api_name,

Line 3236: WHEN OKC_API.G_EXCEPTION_ERROR THEN

3232: raise OKC_API.G_EXCEPTION_ERROR;
3233: END IF;
3234: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
3235: EXCEPTION
3236: WHEN OKC_API.G_EXCEPTION_ERROR THEN
3237: x_return_status := OKC_API.HANDLE_EXCEPTIONS
3238: (l_api_name,
3239: G_PKG_NAME,
3240: 'OKC_API.G_RET_STS_ERROR',

Line 3237: x_return_status := OKC_API.HANDLE_EXCEPTIONS

3233: END IF;
3234: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
3235: EXCEPTION
3236: WHEN OKC_API.G_EXCEPTION_ERROR THEN
3237: x_return_status := OKC_API.HANDLE_EXCEPTIONS
3238: (l_api_name,
3239: G_PKG_NAME,
3240: 'OKC_API.G_RET_STS_ERROR',
3241: x_msg_count,

Line 3240: 'OKC_API.G_RET_STS_ERROR',

3236: WHEN OKC_API.G_EXCEPTION_ERROR THEN
3237: x_return_status := OKC_API.HANDLE_EXCEPTIONS
3238: (l_api_name,
3239: G_PKG_NAME,
3240: 'OKC_API.G_RET_STS_ERROR',
3241: x_msg_count,
3242: x_msg_data,
3243: '_PUB');
3244: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

Line 3244: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

3240: 'OKC_API.G_RET_STS_ERROR',
3241: x_msg_count,
3242: x_msg_data,
3243: '_PUB');
3244: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
3245: x_return_status := OKC_API.HANDLE_EXCEPTIONS
3246: (l_api_name,
3247: G_PKG_NAME,
3248: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 3245: x_return_status := OKC_API.HANDLE_EXCEPTIONS

3241: x_msg_count,
3242: x_msg_data,
3243: '_PUB');
3244: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
3245: x_return_status := OKC_API.HANDLE_EXCEPTIONS
3246: (l_api_name,
3247: G_PKG_NAME,
3248: 'OKC_API.G_RET_STS_UNEXP_ERROR',
3249: x_msg_count,

Line 3248: 'OKC_API.G_RET_STS_UNEXP_ERROR',

3244: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
3245: x_return_status := OKC_API.HANDLE_EXCEPTIONS
3246: (l_api_name,
3247: G_PKG_NAME,
3248: 'OKC_API.G_RET_STS_UNEXP_ERROR',
3249: x_msg_count,
3250: x_msg_data,
3251: '_PUB');
3252: WHEN OTHERS THEN

Line 3253: x_return_status := OKC_API.HANDLE_EXCEPTIONS

3249: x_msg_count,
3250: x_msg_data,
3251: '_PUB');
3252: WHEN OTHERS THEN
3253: x_return_status := OKC_API.HANDLE_EXCEPTIONS
3254: (l_api_name,
3255: G_PKG_NAME,
3256: 'OTHERS',
3257: x_msg_count,

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

3267: x_msg_data OUT NOCOPY VARCHAR2,
3268: p_samv_tbl IN samv_tbl_type,
3269: x_samv_tbl OUT NOCOPY samv_tbl_type) IS
3270: i NUMBER := 0;
3271: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
3272:
3273: BEGIN
3274: x_return_status := OKC_API.G_RET_STS_SUCCESS;
3275: IF p_samv_tbl.COUNT > 0 THEN

Line 3274: x_return_status := OKC_API.G_RET_STS_SUCCESS;

3270: i NUMBER := 0;
3271: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
3272:
3273: BEGIN
3274: x_return_status := OKC_API.G_RET_STS_SUCCESS;
3275: IF p_samv_tbl.COUNT > 0 THEN
3276: i := p_samv_tbl.FIRST;
3277: LOOP
3278: update_std_art_set_mem(

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

3282: x_msg_count => x_msg_count,
3283: x_msg_data => x_msg_data,
3284: p_samv_rec => p_samv_tbl(i),
3285: x_samv_rec => x_samv_tbl(i));
3286: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
3287: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3288: x_return_status := l_return_status;
3289: raise G_EXCEPTION_HALT_PROCESSING;
3290: ELSE

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

3283: x_msg_data => x_msg_data,
3284: p_samv_rec => p_samv_tbl(i),
3285: x_samv_rec => x_samv_tbl(i));
3286: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
3287: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3288: x_return_status := l_return_status;
3289: raise G_EXCEPTION_HALT_PROCESSING;
3290: ELSE
3291: x_return_status := l_return_status;

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

3298: EXCEPTION
3299: WHEN G_EXCEPTION_HALT_PROCESSING THEN
3300: NULL;
3301: WHEN OTHERS THEN
3302: OKC_API.set_message(p_app_name => g_app_name,
3303: p_msg_name => g_unexpected_error,
3304: p_token1 => g_sqlcode_token,
3305: p_token1_value => sqlcode,
3306: p_token2 => g_sqlerrm_token,

Line 3308: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

3304: p_token1 => g_sqlcode_token,
3305: p_token1_value => sqlcode,
3306: p_token2 => g_sqlerrm_token,
3307: p_token2_value => sqlerrm);
3308: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
3309: END update_std_art_set_mem;
3310:
3311: PROCEDURE lock_std_art_set_mem(
3312: p_api_version IN NUMBER,

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

3333: x_msg_count OUT NOCOPY NUMBER,
3334: x_msg_data OUT NOCOPY VARCHAR2,
3335: p_samv_tbl IN samv_tbl_type) IS
3336: i NUMBER := 0;
3337: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
3338:
3339: BEGIN
3340: x_return_status := OKC_API.G_RET_STS_SUCCESS;
3341: IF p_samv_tbl.COUNT > 0 THEN

Line 3340: x_return_status := OKC_API.G_RET_STS_SUCCESS;

3336: i NUMBER := 0;
3337: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
3338:
3339: BEGIN
3340: x_return_status := OKC_API.G_RET_STS_SUCCESS;
3341: IF p_samv_tbl.COUNT > 0 THEN
3342: i := p_samv_tbl.FIRST;
3343: LOOP
3344: lock_std_art_set_mem(

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

3347: x_return_status => l_return_status,
3348: x_msg_count => x_msg_count,
3349: x_msg_data => x_msg_data,
3350: p_samv_rec => p_samv_tbl(i));
3351: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
3352: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3353: x_return_status := l_return_status;
3354: raise G_EXCEPTION_HALT_PROCESSING;
3355: ELSE

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

3348: x_msg_count => x_msg_count,
3349: x_msg_data => x_msg_data,
3350: p_samv_rec => p_samv_tbl(i));
3351: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
3352: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3353: x_return_status := l_return_status;
3354: raise G_EXCEPTION_HALT_PROCESSING;
3355: ELSE
3356: x_return_status := l_return_status;

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

3363: EXCEPTION
3364: WHEN G_EXCEPTION_HALT_PROCESSING THEN
3365: NULL;
3366: WHEN OTHERS THEN
3367: OKC_API.set_message(p_app_name => g_app_name,
3368: p_msg_name => g_unexpected_error,
3369: p_token1 => g_sqlcode_token,
3370: p_token1_value => sqlcode,
3371: p_token2 => g_sqlerrm_token,

Line 3373: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

3369: p_token1 => g_sqlcode_token,
3370: p_token1_value => sqlcode,
3371: p_token2 => g_sqlerrm_token,
3372: p_token2_value => sqlerrm);
3373: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
3374: END lock_std_art_set_mem;
3375:
3376:
3377: PROCEDURE delete_std_art_set_mem(

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

3380: x_return_status OUT NOCOPY VARCHAR2,
3381: x_msg_count OUT NOCOPY NUMBER,
3382: x_msg_data OUT NOCOPY VARCHAR2,
3383: p_samv_rec IN samv_rec_type) IS
3384: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
3385: l_api_name CONSTANT VARCHAR2(30) := 'DELETE_STD_ART_SET_MEM';
3386: l_samv_rec samv_rec_type := p_samv_rec;
3387: BEGIN
3388: l_return_status := OKC_API.START_ACTIVITY(l_api_name,

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

3384: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
3385: l_api_name CONSTANT VARCHAR2(30) := 'DELETE_STD_ART_SET_MEM';
3386: l_samv_rec samv_rec_type := p_samv_rec;
3387: BEGIN
3388: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
3389: p_init_msg_list,
3390: '_PUB',
3391: x_return_status);
3392: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

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

3388: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
3389: p_init_msg_list,
3390: '_PUB',
3391: x_return_status);
3392: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3393: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3394: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
3395: raise OKC_API.G_EXCEPTION_ERROR;
3396: END IF;

Line 3393: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

3389: p_init_msg_list,
3390: '_PUB',
3391: x_return_status);
3392: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3393: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3394: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
3395: raise OKC_API.G_EXCEPTION_ERROR;
3396: END IF;
3397: -- Call user hook for BEFORE

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

3390: '_PUB',
3391: x_return_status);
3392: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3393: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3394: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
3395: raise OKC_API.G_EXCEPTION_ERROR;
3396: END IF;
3397: -- Call user hook for BEFORE
3398: g_samv_rec := l_samv_rec;

Line 3395: raise OKC_API.G_EXCEPTION_ERROR;

3391: x_return_status);
3392: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3393: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3394: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
3395: raise OKC_API.G_EXCEPTION_ERROR;
3396: END IF;
3397: -- Call user hook for BEFORE
3398: g_samv_rec := l_samv_rec;
3399: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');

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

3396: END IF;
3397: -- Call user hook for BEFORE
3398: g_samv_rec := l_samv_rec;
3399: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
3400: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3401: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3402: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3403: raise OKC_API.G_EXCEPTION_ERROR;
3404: END IF;

Line 3401: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

3397: -- Call user hook for BEFORE
3398: g_samv_rec := l_samv_rec;
3399: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
3400: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3401: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3402: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3403: raise OKC_API.G_EXCEPTION_ERROR;
3404: END IF;
3405: l_samv_rec := migrate_samv(l_samv_rec, g_samv_rec);

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

3398: g_samv_rec := l_samv_rec;
3399: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
3400: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3401: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3402: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3403: raise OKC_API.G_EXCEPTION_ERROR;
3404: END IF;
3405: l_samv_rec := migrate_samv(l_samv_rec, g_samv_rec);
3406:

Line 3403: raise OKC_API.G_EXCEPTION_ERROR;

3399: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
3400: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3401: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3402: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3403: raise OKC_API.G_EXCEPTION_ERROR;
3404: END IF;
3405: l_samv_rec := migrate_samv(l_samv_rec, g_samv_rec);
3406:
3407: OKC_STD_ARTICLE_PVT.delete_std_art_set_mem(

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

3411: x_msg_count => x_msg_count,
3412: x_msg_data => x_msg_data,
3413: p_samv_rec => l_samv_rec);
3414:
3415: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3416: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3417: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3418: raise OKC_API.G_EXCEPTION_ERROR;
3419: END IF;

Line 3416: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

3412: x_msg_data => x_msg_data,
3413: p_samv_rec => l_samv_rec);
3414:
3415: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3416: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3417: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3418: raise OKC_API.G_EXCEPTION_ERROR;
3419: END IF;
3420:

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

3413: p_samv_rec => l_samv_rec);
3414:
3415: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3416: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3417: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3418: raise OKC_API.G_EXCEPTION_ERROR;
3419: END IF;
3420:
3421: -- Call user hook for AFTER

Line 3418: raise OKC_API.G_EXCEPTION_ERROR;

3414:
3415: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3416: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3417: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3418: raise OKC_API.G_EXCEPTION_ERROR;
3419: END IF;
3420:
3421: -- Call user hook for AFTER
3422: g_samv_rec := l_samv_rec;

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

3420:
3421: -- Call user hook for AFTER
3422: g_samv_rec := l_samv_rec;
3423: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
3424: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3425: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3426: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3427: raise OKC_API.G_EXCEPTION_ERROR;
3428: END IF;

Line 3425: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

3421: -- Call user hook for AFTER
3422: g_samv_rec := l_samv_rec;
3423: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
3424: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3425: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3426: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3427: raise OKC_API.G_EXCEPTION_ERROR;
3428: END IF;
3429: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

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

3422: g_samv_rec := l_samv_rec;
3423: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
3424: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3425: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3426: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3427: raise OKC_API.G_EXCEPTION_ERROR;
3428: END IF;
3429: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
3430: EXCEPTION

Line 3427: raise OKC_API.G_EXCEPTION_ERROR;

3423: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
3424: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3425: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3426: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3427: raise OKC_API.G_EXCEPTION_ERROR;
3428: END IF;
3429: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
3430: EXCEPTION
3431: WHEN OKC_API.G_EXCEPTION_ERROR THEN

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

3425: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3426: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3427: raise OKC_API.G_EXCEPTION_ERROR;
3428: END IF;
3429: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
3430: EXCEPTION
3431: WHEN OKC_API.G_EXCEPTION_ERROR THEN
3432: x_return_status := OKC_API.HANDLE_EXCEPTIONS
3433: (l_api_name,

Line 3431: WHEN OKC_API.G_EXCEPTION_ERROR THEN

3427: raise OKC_API.G_EXCEPTION_ERROR;
3428: END IF;
3429: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
3430: EXCEPTION
3431: WHEN OKC_API.G_EXCEPTION_ERROR THEN
3432: x_return_status := OKC_API.HANDLE_EXCEPTIONS
3433: (l_api_name,
3434: G_PKG_NAME,
3435: 'OKC_API.G_RET_STS_ERROR',

Line 3432: x_return_status := OKC_API.HANDLE_EXCEPTIONS

3428: END IF;
3429: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
3430: EXCEPTION
3431: WHEN OKC_API.G_EXCEPTION_ERROR THEN
3432: x_return_status := OKC_API.HANDLE_EXCEPTIONS
3433: (l_api_name,
3434: G_PKG_NAME,
3435: 'OKC_API.G_RET_STS_ERROR',
3436: x_msg_count,

Line 3435: 'OKC_API.G_RET_STS_ERROR',

3431: WHEN OKC_API.G_EXCEPTION_ERROR THEN
3432: x_return_status := OKC_API.HANDLE_EXCEPTIONS
3433: (l_api_name,
3434: G_PKG_NAME,
3435: 'OKC_API.G_RET_STS_ERROR',
3436: x_msg_count,
3437: x_msg_data,
3438: '_PUB');
3439: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

Line 3439: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

3435: 'OKC_API.G_RET_STS_ERROR',
3436: x_msg_count,
3437: x_msg_data,
3438: '_PUB');
3439: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
3440: x_return_status := OKC_API.HANDLE_EXCEPTIONS
3441: (l_api_name,
3442: G_PKG_NAME,
3443: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 3440: x_return_status := OKC_API.HANDLE_EXCEPTIONS

3436: x_msg_count,
3437: x_msg_data,
3438: '_PUB');
3439: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
3440: x_return_status := OKC_API.HANDLE_EXCEPTIONS
3441: (l_api_name,
3442: G_PKG_NAME,
3443: 'OKC_API.G_RET_STS_UNEXP_ERROR',
3444: x_msg_count,

Line 3443: 'OKC_API.G_RET_STS_UNEXP_ERROR',

3439: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
3440: x_return_status := OKC_API.HANDLE_EXCEPTIONS
3441: (l_api_name,
3442: G_PKG_NAME,
3443: 'OKC_API.G_RET_STS_UNEXP_ERROR',
3444: x_msg_count,
3445: x_msg_data,
3446: '_PUB');
3447: WHEN OTHERS THEN

Line 3448: x_return_status := OKC_API.HANDLE_EXCEPTIONS

3444: x_msg_count,
3445: x_msg_data,
3446: '_PUB');
3447: WHEN OTHERS THEN
3448: x_return_status := OKC_API.HANDLE_EXCEPTIONS
3449: (l_api_name,
3450: G_PKG_NAME,
3451: 'OTHERS',
3452: x_msg_count,

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

3461: x_msg_count OUT NOCOPY NUMBER,
3462: x_msg_data OUT NOCOPY VARCHAR2,
3463: p_samv_tbl IN samv_tbl_type) IS
3464: i NUMBER := 0;
3465: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
3466:
3467: BEGIN
3468: x_return_status := OKC_API.G_RET_STS_SUCCESS;
3469: IF p_samv_tbl.COUNT > 0 THEN

Line 3468: x_return_status := OKC_API.G_RET_STS_SUCCESS;

3464: i NUMBER := 0;
3465: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
3466:
3467: BEGIN
3468: x_return_status := OKC_API.G_RET_STS_SUCCESS;
3469: IF p_samv_tbl.COUNT > 0 THEN
3470: i := p_samv_tbl.FIRST;
3471: LOOP
3472: delete_std_art_set_mem(

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

3475: x_return_status => l_return_status,
3476: x_msg_count => x_msg_count,
3477: x_msg_data => x_msg_data,
3478: p_samv_rec => p_samv_tbl(i));
3479: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
3480: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3481: x_return_status := l_return_status;
3482: raise G_EXCEPTION_HALT_PROCESSING;
3483: ELSE

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

3476: x_msg_count => x_msg_count,
3477: x_msg_data => x_msg_data,
3478: p_samv_rec => p_samv_tbl(i));
3479: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
3480: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3481: x_return_status := l_return_status;
3482: raise G_EXCEPTION_HALT_PROCESSING;
3483: ELSE
3484: x_return_status := l_return_status;

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

3491: EXCEPTION
3492: WHEN G_EXCEPTION_HALT_PROCESSING THEN
3493: NULL;
3494: WHEN OTHERS THEN
3495: OKC_API.set_message(p_app_name => g_app_name,
3496: p_msg_name => g_unexpected_error,
3497: p_token1 => g_sqlcode_token,
3498: p_token1_value => sqlcode,
3499: p_token2 => g_sqlerrm_token,

Line 3501: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

3497: p_token1 => g_sqlcode_token,
3498: p_token1_value => sqlcode,
3499: p_token2 => g_sqlerrm_token,
3500: p_token2_value => sqlerrm);
3501: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
3502: END delete_std_art_set_mem;
3503:
3504:
3505: PROCEDURE validate_std_art_set_mem(

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

3528: x_msg_count OUT NOCOPY NUMBER,
3529: x_msg_data OUT NOCOPY VARCHAR2,
3530: p_samv_tbl IN samv_tbl_type) IS
3531: i NUMBER := 0;
3532: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
3533:
3534: BEGIN
3535: x_return_status := OKC_API.G_RET_STS_SUCCESS;
3536: IF p_samv_tbl.COUNT > 0 THEN

Line 3535: x_return_status := OKC_API.G_RET_STS_SUCCESS;

3531: i NUMBER := 0;
3532: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
3533:
3534: BEGIN
3535: x_return_status := OKC_API.G_RET_STS_SUCCESS;
3536: IF p_samv_tbl.COUNT > 0 THEN
3537: i := p_samv_tbl.FIRST;
3538: LOOP
3539: validate_std_art_set_mem(

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

3542: x_return_status => l_return_status,
3543: x_msg_count => x_msg_count,
3544: x_msg_data => x_msg_data,
3545: p_samv_rec => p_samv_tbl(i));
3546: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
3547: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3548: x_return_status := l_return_status;
3549: raise G_EXCEPTION_HALT_PROCESSING;
3550: ELSE

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

3543: x_msg_count => x_msg_count,
3544: x_msg_data => x_msg_data,
3545: p_samv_rec => p_samv_tbl(i));
3546: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
3547: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3548: x_return_status := l_return_status;
3549: raise G_EXCEPTION_HALT_PROCESSING;
3550: ELSE
3551: x_return_status := l_return_status;

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

3558: EXCEPTION
3559: WHEN G_EXCEPTION_HALT_PROCESSING THEN
3560: NULL;
3561: WHEN OTHERS THEN
3562: OKC_API.set_message(p_app_name => g_app_name,
3563: p_msg_name => g_unexpected_error,
3564: p_token1 => g_sqlcode_token,
3565: p_token1_value => sqlcode,
3566: p_token2 => g_sqlerrm_token,

Line 3568: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

3564: p_token1 => g_sqlcode_token,
3565: p_token1_value => sqlcode,
3566: p_token2 => g_sqlerrm_token,
3567: p_token2_value => sqlerrm);
3568: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
3569: END validate_std_art_set_mem;
3570:
3571: PROCEDURE validate_unique(
3572: p_api_version IN NUMBER,