APPS.OKC_VERSION_PVT dependencies on OKC_API

Line 16: p_init_msg_list IN VARCHAR2 DEFAULT OKC_API.G_FALSE,

12: p_chr_id IN NUMBER,
13: p_action IN VARCHAR2,
14: p_major_version IN NUMBER,
15: p_api_version IN NUMBER,
16: p_init_msg_list IN VARCHAR2 DEFAULT OKC_API.G_FALSE,
17: x_return_status OUT NOCOPY VARCHAR2,
18: x_msg_count OUT NOCOPY NUMBER,
19: x_msg_data OUT NOCOPY VARCHAR2) IS
20: --

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

20: --
21: --
22: l_api_version CONSTANT NUMBER := 1;
23: l_api_name CONSTANT VARCHAR2(30) := 'V_version_attachments';
24: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
25: l_major_version number(4);
26: l_minor_version number ;
27: l_minus_version number := -1;
28: l_rest_to_major_ver number(4);

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

47: and major_version = l_minus_version;
48:
49: begin
50:
51: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
52: G_PKG_NAME,
53: p_init_msg_list,
54: l_api_version,
55: p_api_version,

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

54: l_api_version,
55: p_api_version,
56: '_PVT',
57: x_return_status);
58: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
59: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
60: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
61: RAISE OKC_API.G_EXCEPTION_ERROR;
62: END IF;

Line 59: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

55: p_api_version,
56: '_PVT',
57: x_return_status);
58: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
59: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
60: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
61: RAISE OKC_API.G_EXCEPTION_ERROR;
62: END IF;
63:

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

56: '_PVT',
57: x_return_status);
58: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
59: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
60: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
61: RAISE OKC_API.G_EXCEPTION_ERROR;
62: END IF;
63:
64: -- added for Bug 3431701

Line 61: RAISE OKC_API.G_EXCEPTION_ERROR;

57: x_return_status);
58: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
59: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
60: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
61: RAISE OKC_API.G_EXCEPTION_ERROR;
62: END IF;
63:
64: -- added for Bug 3431701
65: Set_Attach_Session_Vars(p_chr_id);

Line 277: WHEN OKC_API.G_EXCEPTION_ERROR THEN

273: -- Added on 03/29/2001
274: end if;
275: EXCEPTION
276:
277: WHEN OKC_API.G_EXCEPTION_ERROR THEN
278: x_return_status := OKC_API.HANDLE_EXCEPTIONS
279: (
280: l_api_name,
281: G_PKG_NAME,

Line 278: x_return_status := OKC_API.HANDLE_EXCEPTIONS

274: end if;
275: EXCEPTION
276:
277: WHEN OKC_API.G_EXCEPTION_ERROR THEN
278: x_return_status := OKC_API.HANDLE_EXCEPTIONS
279: (
280: l_api_name,
281: G_PKG_NAME,
282: 'OKC_API.G_RET_STS_ERROR',

Line 282: 'OKC_API.G_RET_STS_ERROR',

278: x_return_status := OKC_API.HANDLE_EXCEPTIONS
279: (
280: l_api_name,
281: G_PKG_NAME,
282: 'OKC_API.G_RET_STS_ERROR',
283: x_msg_count,
284: x_msg_data,
285: '_PVT'
286: );

Line 287: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

283: x_msg_count,
284: x_msg_data,
285: '_PVT'
286: );
287: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
288: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
289: (
290: l_api_name,
291: G_PKG_NAME,

Line 288: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

284: x_msg_data,
285: '_PVT'
286: );
287: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
288: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
289: (
290: l_api_name,
291: G_PKG_NAME,
292: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 292: 'OKC_API.G_RET_STS_UNEXP_ERROR',

288: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
289: (
290: l_api_name,
291: G_PKG_NAME,
292: 'OKC_API.G_RET_STS_UNEXP_ERROR',
293: x_msg_count,
294: x_msg_data,
295: '_PVT'
296: );

Line 298: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

294: x_msg_data,
295: '_PVT'
296: );
297: WHEN OTHERS THEN
298: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
299: (
300: l_api_name,
301: G_PKG_NAME,
302: 'OTHERS',

Line 341: p_init_msg_list IN VARCHAR2 DEFAULT OKC_API.G_FALSE,

337: --Public procedure to version various components of a contract
338: --
339: PROCEDURE version_contract(
340: p_api_version IN NUMBER,
341: p_init_msg_list IN VARCHAR2 DEFAULT OKC_API.G_FALSE,
342: x_return_status OUT NOCOPY VARCHAR2,
343: x_msg_count OUT NOCOPY NUMBER,
344: x_msg_data OUT NOCOPY VARCHAR2,
345: p_cvmv_rec IN cvmv_rec_type,

Line 347: p_commit IN VARCHAR2 DEFAULT OKC_API.G_TRUE) IS

343: x_msg_count OUT NOCOPY NUMBER,
344: x_msg_data OUT NOCOPY VARCHAR2,
345: p_cvmv_rec IN cvmv_rec_type,
346: x_cvmv_rec OUT NOCOPY cvmv_rec_type,
347: p_commit IN VARCHAR2 DEFAULT OKC_API.G_TRUE) IS
348:
349:
350: l_api_version CONSTANT NUMBER := 1;
351: l_api_name CONSTANT VARCHAR2(30) := 'V_Version_Contract';

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

348:
349:
350: l_api_version CONSTANT NUMBER := 1;
351: l_api_name CONSTANT VARCHAR2(30) := 'V_Version_Contract';
352: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
353: l_chr_id Number;
354: l_major_version Number;
355: l_cvmv_rec cvmv_rec_type;
356: l_cls_code OKC_SUBCLASSES_B.CLS_CODE%TYPE:=OKC_API.G_MISS_CHAR;

Line 356: l_cls_code OKC_SUBCLASSES_B.CLS_CODE%TYPE:=OKC_API.G_MISS_CHAR;

352: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
353: l_chr_id Number;
354: l_major_version Number;
355: l_cvmv_rec cvmv_rec_type;
356: l_cls_code OKC_SUBCLASSES_B.CLS_CODE%TYPE:=OKC_API.G_MISS_CHAR;
357: l_pdf_id NUMBER := NULL;
358: l_string VARCHAR2(4000);
359: proc_string VARCHAR2(4000);
360: l_msg_data varchar2(2000);

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

374: FROM okc_class_operations
375: WHERE opn_code = 'VERSIONING'
376: AND cls_code = p_cls_code;
377: BEGIN
378: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
379: G_PKG_NAME,
380: p_init_msg_list,
381: l_api_version,
382: p_api_version,

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

381: l_api_version,
382: p_api_version,
383: '_PVT',
384: x_return_status);
385: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
386: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
387: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
388: RAISE OKC_API.G_EXCEPTION_ERROR;
389: END IF;

Line 386: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

382: p_api_version,
383: '_PVT',
384: x_return_status);
385: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
386: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
387: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
388: RAISE OKC_API.G_EXCEPTION_ERROR;
389: END IF;
390: -- Get the version number from okc_k_vers_numbers

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

383: '_PVT',
384: x_return_status);
385: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
386: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
387: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
388: RAISE OKC_API.G_EXCEPTION_ERROR;
389: END IF;
390: -- Get the version number from okc_k_vers_numbers
391: okc_cvm_pvt.version_contract_version(

Line 388: RAISE OKC_API.G_EXCEPTION_ERROR;

384: x_return_status);
385: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
386: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
387: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
388: RAISE OKC_API.G_EXCEPTION_ERROR;
389: END IF;
390: -- Get the version number from okc_k_vers_numbers
391: okc_cvm_pvt.version_contract_version(
392: p_api_version =>p_api_version,

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

398: x_cvmv_rec =>l_cvmv_rec);
399:
400: --- If any errors happen abort API
401:
402: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
403: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
404: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
405: RAISE OKC_API.G_EXCEPTION_ERROR;
406: END IF;

Line 403: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

399:
400: --- If any errors happen abort API
401:
402: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
403: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
404: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
405: RAISE OKC_API.G_EXCEPTION_ERROR;
406: END IF;
407: --

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

400: --- If any errors happen abort API
401:
402: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
403: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
404: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
405: RAISE OKC_API.G_EXCEPTION_ERROR;
406: END IF;
407: --
408: l_chr_id:=l_cvmv_rec.chr_id;

Line 405: RAISE OKC_API.G_EXCEPTION_ERROR;

401:
402: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
403: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
404: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
405: RAISE OKC_API.G_EXCEPTION_ERROR;
406: END IF;
407: --
408: l_chr_id:=l_cvmv_rec.chr_id;
409: l_major_version:=l_cvmv_rec.major_version;

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

424: IF l_string is NOT NULL THEN
425: proc_string := 'begin '||l_string || ' (:b1,:b2); end ;';
426: EXECUTE IMMEDIATE proc_string using l_chr_id, out l_return_status;
427:
428: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
429: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
430: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
431: RAISE OKC_API.G_EXCEPTION_ERROR;
432: END IF;

Line 429: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

425: proc_string := 'begin '||l_string || ' (:b1,:b2); end ;';
426: EXECUTE IMMEDIATE proc_string using l_chr_id, out l_return_status;
427:
428: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
429: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
430: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
431: RAISE OKC_API.G_EXCEPTION_ERROR;
432: END IF;
433: End If;

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

426: EXECUTE IMMEDIATE proc_string using l_chr_id, out l_return_status;
427:
428: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
429: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
430: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
431: RAISE OKC_API.G_EXCEPTION_ERROR;
432: END IF;
433: End If;
434: --

Line 431: RAISE OKC_API.G_EXCEPTION_ERROR;

427:
428: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
429: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
430: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
431: RAISE OKC_API.G_EXCEPTION_ERROR;
432: END IF;
433: End If;
434: --
435: -- Version Attachments - CREATE_VERSION

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

441: x_return_status =>l_return_status,
442: x_msg_count =>x_msg_count,
443: x_msg_data =>x_msg_data);
444: --
445: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
446: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
447: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
448: RAISE OKC_API.G_EXCEPTION_ERROR;
449: END IF;

Line 446: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

442: x_msg_count =>x_msg_count,
443: x_msg_data =>x_msg_data);
444: --
445: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
446: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
447: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
448: RAISE OKC_API.G_EXCEPTION_ERROR;
449: END IF;
450: --

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

443: x_msg_data =>x_msg_data);
444: --
445: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
446: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
447: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
448: RAISE OKC_API.G_EXCEPTION_ERROR;
449: END IF;
450: --
451: --version contract header

Line 448: RAISE OKC_API.G_EXCEPTION_ERROR;

444: --
445: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
446: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
447: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
448: RAISE OKC_API.G_EXCEPTION_ERROR;
449: END IF;
450: --
451: --version contract header
452: --

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

451: --version contract header
452: --
453: l_return_status:=OKC_CHR_PVT.Create_Version(l_chr_id,l_major_version);
454: --- If any errors happen abort API
455: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
456: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
457: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
458: RAISE OKC_API.G_EXCEPTION_ERROR;
459: END IF;

Line 456: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

452: --
453: l_return_status:=OKC_CHR_PVT.Create_Version(l_chr_id,l_major_version);
454: --- If any errors happen abort API
455: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
456: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
457: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
458: RAISE OKC_API.G_EXCEPTION_ERROR;
459: END IF;
460:

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

453: l_return_status:=OKC_CHR_PVT.Create_Version(l_chr_id,l_major_version);
454: --- If any errors happen abort API
455: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
456: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
457: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
458: RAISE OKC_API.G_EXCEPTION_ERROR;
459: END IF;
460:
461: --version contract lines

Line 458: RAISE OKC_API.G_EXCEPTION_ERROR;

454: --- If any errors happen abort API
455: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
456: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
457: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
458: RAISE OKC_API.G_EXCEPTION_ERROR;
459: END IF;
460:
461: --version contract lines
462:

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

461: --version contract lines
462:
463: l_return_status:=OKC_CLE_PVT.Create_Version(l_chr_id,l_major_version);
464: --- If any errors happen abort API
465: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
466: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
467: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
468: RAISE OKC_API.G_EXCEPTION_ERROR;
469: END IF;

Line 466: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

462:
463: l_return_status:=OKC_CLE_PVT.Create_Version(l_chr_id,l_major_version);
464: --- If any errors happen abort API
465: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
466: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
467: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
468: RAISE OKC_API.G_EXCEPTION_ERROR;
469: END IF;
470:

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

463: l_return_status:=OKC_CLE_PVT.Create_Version(l_chr_id,l_major_version);
464: --- If any errors happen abort API
465: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
466: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
467: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
468: RAISE OKC_API.G_EXCEPTION_ERROR;
469: END IF;
470:
471: --version contract items

Line 468: RAISE OKC_API.G_EXCEPTION_ERROR;

464: --- If any errors happen abort API
465: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
466: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
467: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
468: RAISE OKC_API.G_EXCEPTION_ERROR;
469: END IF;
470:
471: --version contract items
472: l_return_status:=OKC_CIM_PVT.Create_Version(l_chr_id,l_major_version);

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

470:
471: --version contract items
472: l_return_status:=OKC_CIM_PVT.Create_Version(l_chr_id,l_major_version);
473: --- If any errors happen abort API
474: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
475: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
476: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
477: RAISE OKC_API.G_EXCEPTION_ERROR;
478: END IF;

Line 475: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

471: --version contract items
472: l_return_status:=OKC_CIM_PVT.Create_Version(l_chr_id,l_major_version);
473: --- If any errors happen abort API
474: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
475: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
476: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
477: RAISE OKC_API.G_EXCEPTION_ERROR;
478: END IF;
479:

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

472: l_return_status:=OKC_CIM_PVT.Create_Version(l_chr_id,l_major_version);
473: --- If any errors happen abort API
474: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
475: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
476: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
477: RAISE OKC_API.G_EXCEPTION_ERROR;
478: END IF;
479:
480: --version contract party roles

Line 477: RAISE OKC_API.G_EXCEPTION_ERROR;

473: --- If any errors happen abort API
474: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
475: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
476: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
477: RAISE OKC_API.G_EXCEPTION_ERROR;
478: END IF;
479:
480: --version contract party roles
481: l_return_status:=OKC_CPL_PVT.Create_Version(l_chr_id,l_major_version);

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

479:
480: --version contract party roles
481: l_return_status:=OKC_CPL_PVT.Create_Version(l_chr_id,l_major_version);
482: --- If any errors happen abort API
483: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
484: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
485: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
486: RAISE OKC_API.G_EXCEPTION_ERROR;
487: END IF;

Line 484: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

480: --version contract party roles
481: l_return_status:=OKC_CPL_PVT.Create_Version(l_chr_id,l_major_version);
482: --- If any errors happen abort API
483: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
484: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
485: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
486: RAISE OKC_API.G_EXCEPTION_ERROR;
487: END IF;
488:

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

481: l_return_status:=OKC_CPL_PVT.Create_Version(l_chr_id,l_major_version);
482: --- If any errors happen abort API
483: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
484: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
485: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
486: RAISE OKC_API.G_EXCEPTION_ERROR;
487: END IF;
488:
489: --version RuleGroup party roles

Line 486: RAISE OKC_API.G_EXCEPTION_ERROR;

482: --- If any errors happen abort API
483: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
484: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
485: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
486: RAISE OKC_API.G_EXCEPTION_ERROR;
487: END IF;
488:
489: --version RuleGroup party roles
490: l_return_status:=OKC_RMP_PVT.Create_Version(l_chr_id,l_major_version);

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

488:
489: --version RuleGroup party roles
490: l_return_status:=OKC_RMP_PVT.Create_Version(l_chr_id,l_major_version);
491: --- If any errors happen abort API
492: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
493: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
494: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
495: RAISE OKC_API.G_EXCEPTION_ERROR;
496: END IF;

Line 493: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

489: --version RuleGroup party roles
490: l_return_status:=OKC_RMP_PVT.Create_Version(l_chr_id,l_major_version);
491: --- If any errors happen abort API
492: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
493: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
494: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
495: RAISE OKC_API.G_EXCEPTION_ERROR;
496: END IF;
497:

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

490: l_return_status:=OKC_RMP_PVT.Create_Version(l_chr_id,l_major_version);
491: --- If any errors happen abort API
492: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
493: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
494: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
495: RAISE OKC_API.G_EXCEPTION_ERROR;
496: END IF;
497:
498: --version Rule Groups

Line 495: RAISE OKC_API.G_EXCEPTION_ERROR;

491: --- If any errors happen abort API
492: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
493: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
494: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
495: RAISE OKC_API.G_EXCEPTION_ERROR;
496: END IF;
497:
498: --version Rule Groups
499: l_return_status:=OKC_RGP_PVT.Create_Version(l_chr_id,l_major_version);

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

497:
498: --version Rule Groups
499: l_return_status:=OKC_RGP_PVT.Create_Version(l_chr_id,l_major_version);
500: --- If any errors happen abort API
501: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
502: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
503: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
504: RAISE OKC_API.G_EXCEPTION_ERROR;
505: END IF;

Line 502: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

498: --version Rule Groups
499: l_return_status:=OKC_RGP_PVT.Create_Version(l_chr_id,l_major_version);
500: --- If any errors happen abort API
501: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
502: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
503: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
504: RAISE OKC_API.G_EXCEPTION_ERROR;
505: END IF;
506:

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

499: l_return_status:=OKC_RGP_PVT.Create_Version(l_chr_id,l_major_version);
500: --- If any errors happen abort API
501: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
502: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
503: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
504: RAISE OKC_API.G_EXCEPTION_ERROR;
505: END IF;
506:
507: --version Rules

Line 504: RAISE OKC_API.G_EXCEPTION_ERROR;

500: --- If any errors happen abort API
501: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
502: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
503: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
504: RAISE OKC_API.G_EXCEPTION_ERROR;
505: END IF;
506:
507: --version Rules
508: l_return_status:=OKC_RUL_PVT.Create_Version(l_chr_id,l_major_version);

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

506:
507: --version Rules
508: l_return_status:=OKC_RUL_PVT.Create_Version(l_chr_id,l_major_version);
509: --- If any errors happen abort API
510: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
511: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
512: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
513: RAISE OKC_API.G_EXCEPTION_ERROR;
514: END IF;

Line 511: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

507: --version Rules
508: l_return_status:=OKC_RUL_PVT.Create_Version(l_chr_id,l_major_version);
509: --- If any errors happen abort API
510: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
511: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
512: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
513: RAISE OKC_API.G_EXCEPTION_ERROR;
514: END IF;
515:

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

508: l_return_status:=OKC_RUL_PVT.Create_Version(l_chr_id,l_major_version);
509: --- If any errors happen abort API
510: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
511: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
512: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
513: RAISE OKC_API.G_EXCEPTION_ERROR;
514: END IF;
515:
516:

Line 513: RAISE OKC_API.G_EXCEPTION_ERROR;

509: --- If any errors happen abort API
510: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
511: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
512: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
513: RAISE OKC_API.G_EXCEPTION_ERROR;
514: END IF;
515:
516:
517: --version Contacts

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

516:
517: --version Contacts
518: l_return_status:=OKC_CTC_PVT.Create_Version(l_chr_id,l_major_version);
519: --- If any errors happen abort API
520: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
521: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
522: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
523: RAISE OKC_API.G_EXCEPTION_ERROR;
524: END IF;

Line 521: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

517: --version Contacts
518: l_return_status:=OKC_CTC_PVT.Create_Version(l_chr_id,l_major_version);
519: --- If any errors happen abort API
520: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
521: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
522: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
523: RAISE OKC_API.G_EXCEPTION_ERROR;
524: END IF;
525:

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

518: l_return_status:=OKC_CTC_PVT.Create_Version(l_chr_id,l_major_version);
519: --- If any errors happen abort API
520: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
521: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
522: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
523: RAISE OKC_API.G_EXCEPTION_ERROR;
524: END IF;
525:
526: --version cover times

Line 523: RAISE OKC_API.G_EXCEPTION_ERROR;

519: --- If any errors happen abort API
520: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
521: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
522: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
523: RAISE OKC_API.G_EXCEPTION_ERROR;
524: END IF;
525:
526: --version cover times
527: l_return_status:=OKC_CTI_PVT.Create_Version(l_chr_id,l_major_version);

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

525:
526: --version cover times
527: l_return_status:=OKC_CTI_PVT.Create_Version(l_chr_id,l_major_version);
528: --- If any errors happen abort API
529: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
530: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
531: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
532: RAISE OKC_API.G_EXCEPTION_ERROR;
533: END IF;

Line 530: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

526: --version cover times
527: l_return_status:=OKC_CTI_PVT.Create_Version(l_chr_id,l_major_version);
528: --- If any errors happen abort API
529: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
530: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
531: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
532: RAISE OKC_API.G_EXCEPTION_ERROR;
533: END IF;
534:

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

527: l_return_status:=OKC_CTI_PVT.Create_Version(l_chr_id,l_major_version);
528: --- If any errors happen abort API
529: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
530: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
531: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
532: RAISE OKC_API.G_EXCEPTION_ERROR;
533: END IF;
534:
535: --version contract accesses

Line 532: RAISE OKC_API.G_EXCEPTION_ERROR;

528: --- If any errors happen abort API
529: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
530: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
531: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
532: RAISE OKC_API.G_EXCEPTION_ERROR;
533: END IF;
534:
535: --version contract accesses
536: l_return_status:=OKC_CAC_PVT.Create_Version(l_chr_id,l_major_version);

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

534:
535: --version contract accesses
536: l_return_status:=OKC_CAC_PVT.Create_Version(l_chr_id,l_major_version);
537: --- If any errors happen abort API
538: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
539: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
540: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
541: RAISE OKC_API.G_EXCEPTION_ERROR;
542: END IF;

Line 539: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

535: --version contract accesses
536: l_return_status:=OKC_CAC_PVT.Create_Version(l_chr_id,l_major_version);
537: --- If any errors happen abort API
538: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
539: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
540: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
541: RAISE OKC_API.G_EXCEPTION_ERROR;
542: END IF;
543:

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

536: l_return_status:=OKC_CAC_PVT.Create_Version(l_chr_id,l_major_version);
537: --- If any errors happen abort API
538: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
539: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
540: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
541: RAISE OKC_API.G_EXCEPTION_ERROR;
542: END IF;
543:
544: --version outcome arguments

Line 541: RAISE OKC_API.G_EXCEPTION_ERROR;

537: --- If any errors happen abort API
538: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
539: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
540: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
541: RAISE OKC_API.G_EXCEPTION_ERROR;
542: END IF;
543:
544: --version outcome arguments
545: l_return_status:=OKC_OAT_PVT.Create_Version(l_chr_id,l_major_version);

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

543:
544: --version outcome arguments
545: l_return_status:=OKC_OAT_PVT.Create_Version(l_chr_id,l_major_version);
546: --- If any errors happen abort API
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: --version outcome arguments
545: l_return_status:=OKC_OAT_PVT.Create_Version(l_chr_id,l_major_version);
546: --- If any errors happen abort API
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:

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

545: l_return_status:=OKC_OAT_PVT.Create_Version(l_chr_id,l_major_version);
546: --- If any errors happen abort API
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:
553: --version outcomes

Line 550: RAISE OKC_API.G_EXCEPTION_ERROR;

546: --- If any errors happen abort API
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:
553: --version outcomes
554: l_return_status:=OKC_OCE_PVT.Create_Version(l_chr_id,l_major_version);

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

552:
553: --version outcomes
554: l_return_status:=OKC_OCE_PVT.Create_Version(l_chr_id,l_major_version);
555: --- If any errors happen abort API
556: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
557: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
558: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
559: RAISE OKC_API.G_EXCEPTION_ERROR;
560: END IF;

Line 557: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

553: --version outcomes
554: l_return_status:=OKC_OCE_PVT.Create_Version(l_chr_id,l_major_version);
555: --- If any errors happen abort API
556: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
557: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
558: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
559: RAISE OKC_API.G_EXCEPTION_ERROR;
560: END IF;
561:

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

554: l_return_status:=OKC_OCE_PVT.Create_Version(l_chr_id,l_major_version);
555: --- If any errors happen abort API
556: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
557: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
558: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
559: RAISE OKC_API.G_EXCEPTION_ERROR;
560: END IF;
561:
562: --version react intervals

Line 559: RAISE OKC_API.G_EXCEPTION_ERROR;

555: --- If any errors happen abort API
556: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
557: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
558: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
559: RAISE OKC_API.G_EXCEPTION_ERROR;
560: END IF;
561:
562: --version react intervals
563: l_return_status:=OKC_RIL_PVT.Create_Version(l_chr_id,l_major_version);

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

561:
562: --version react intervals
563: l_return_status:=OKC_RIL_PVT.Create_Version(l_chr_id,l_major_version);
564: --- If any errors happen abort API
565: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
566: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
567: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
568: RAISE OKC_API.G_EXCEPTION_ERROR;
569: END IF;

Line 566: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

562: --version react intervals
563: l_return_status:=OKC_RIL_PVT.Create_Version(l_chr_id,l_major_version);
564: --- If any errors happen abort API
565: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
566: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
567: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
568: RAISE OKC_API.G_EXCEPTION_ERROR;
569: END IF;
570:

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

563: l_return_status:=OKC_RIL_PVT.Create_Version(l_chr_id,l_major_version);
564: --- If any errors happen abort API
565: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
566: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
567: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
568: RAISE OKC_API.G_EXCEPTION_ERROR;
569: END IF;
570:
571:

Line 568: RAISE OKC_API.G_EXCEPTION_ERROR;

564: --- If any errors happen abort API
565: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
566: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
567: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
568: RAISE OKC_API.G_EXCEPTION_ERROR;
569: END IF;
570:
571:
572: --version timevalues

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

571:
572: --version timevalues
573: l_return_status:=OKC_TAV_PVT.Create_Version(l_chr_id,l_major_version);
574: --- If any errors happen abort API
575: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
576: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
577: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
578: RAISE OKC_API.G_EXCEPTION_ERROR;
579: END IF;

Line 576: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

572: --version timevalues
573: l_return_status:=OKC_TAV_PVT.Create_Version(l_chr_id,l_major_version);
574: --- If any errors happen abort API
575: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
576: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
577: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
578: RAISE OKC_API.G_EXCEPTION_ERROR;
579: END IF;
580:

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

573: l_return_status:=OKC_TAV_PVT.Create_Version(l_chr_id,l_major_version);
574: --- If any errors happen abort API
575: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
576: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
577: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
578: RAISE OKC_API.G_EXCEPTION_ERROR;
579: END IF;
580:
581: --version contract processes

Line 578: RAISE OKC_API.G_EXCEPTION_ERROR;

574: --- If any errors happen abort API
575: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
576: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
577: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
578: RAISE OKC_API.G_EXCEPTION_ERROR;
579: END IF;
580:
581: --version contract processes
582: l_return_status:=OKC_CPS_PVT.Create_Version(l_chr_id,l_major_version);

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

580:
581: --version contract processes
582: l_return_status:=OKC_CPS_PVT.Create_Version(l_chr_id,l_major_version);
583: --- If any errors happen abort API
584: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
585: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
586: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
587: RAISE OKC_API.G_EXCEPTION_ERROR;
588: END IF;

Line 585: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

581: --version contract processes
582: l_return_status:=OKC_CPS_PVT.Create_Version(l_chr_id,l_major_version);
583: --- If any errors happen abort API
584: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
585: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
586: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
587: RAISE OKC_API.G_EXCEPTION_ERROR;
588: END IF;
589:

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

582: l_return_status:=OKC_CPS_PVT.Create_Version(l_chr_id,l_major_version);
583: --- If any errors happen abort API
584: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
585: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
586: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
587: RAISE OKC_API.G_EXCEPTION_ERROR;
588: END IF;
589:
590: --version condition headers

Line 587: RAISE OKC_API.G_EXCEPTION_ERROR;

583: --- If any errors happen abort API
584: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
585: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
586: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
587: RAISE OKC_API.G_EXCEPTION_ERROR;
588: END IF;
589:
590: --version condition headers
591: l_return_status:=OKC_CNH_PVT.Create_Version(l_chr_id,l_major_version);

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

589:
590: --version condition headers
591: l_return_status:=OKC_CNH_PVT.Create_Version(l_chr_id,l_major_version);
592: --- If any errors happen abort API
593: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
594: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
595: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
596: RAISE OKC_API.G_EXCEPTION_ERROR;
597: END IF;

Line 594: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

590: --version condition headers
591: l_return_status:=OKC_CNH_PVT.Create_Version(l_chr_id,l_major_version);
592: --- If any errors happen abort API
593: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
594: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
595: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
596: RAISE OKC_API.G_EXCEPTION_ERROR;
597: END IF;
598:

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

591: l_return_status:=OKC_CNH_PVT.Create_Version(l_chr_id,l_major_version);
592: --- If any errors happen abort API
593: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
594: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
595: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
596: RAISE OKC_API.G_EXCEPTION_ERROR;
597: END IF;
598:
599:

Line 596: RAISE OKC_API.G_EXCEPTION_ERROR;

592: --- If any errors happen abort API
593: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
594: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
595: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
596: RAISE OKC_API.G_EXCEPTION_ERROR;
597: END IF;
598:
599:
600: --version condition lines

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

599:
600: --version condition lines
601: l_return_status:=OKC_CNL_PVT.Create_Version(l_chr_id,l_major_version);
602: --- If any errors happen abort API
603: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
604: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
605: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
606: RAISE OKC_API.G_EXCEPTION_ERROR;
607: END IF;

Line 604: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

600: --version condition lines
601: l_return_status:=OKC_CNL_PVT.Create_Version(l_chr_id,l_major_version);
602: --- If any errors happen abort API
603: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
604: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
605: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
606: RAISE OKC_API.G_EXCEPTION_ERROR;
607: END IF;
608:

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

601: l_return_status:=OKC_CNL_PVT.Create_Version(l_chr_id,l_major_version);
602: --- If any errors happen abort API
603: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
604: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
605: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
606: RAISE OKC_API.G_EXCEPTION_ERROR;
607: END IF;
608:
609: --version function_expr_params

Line 606: RAISE OKC_API.G_EXCEPTION_ERROR;

602: --- If any errors happen abort API
603: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
604: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
605: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
606: RAISE OKC_API.G_EXCEPTION_ERROR;
607: END IF;
608:
609: --version function_expr_params
610: l_return_status:=OKC_FEP_PVT.Create_Version(l_chr_id,l_major_version);

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

608:
609: --version function_expr_params
610: l_return_status:=OKC_FEP_PVT.Create_Version(l_chr_id,l_major_version);
611: --- If any errors happen abort API
612: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
613: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
614: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
615: RAISE OKC_API.G_EXCEPTION_ERROR;
616: END IF;

Line 613: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

609: --version function_expr_params
610: l_return_status:=OKC_FEP_PVT.Create_Version(l_chr_id,l_major_version);
611: --- If any errors happen abort API
612: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
613: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
614: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
615: RAISE OKC_API.G_EXCEPTION_ERROR;
616: END IF;
617:

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

610: l_return_status:=OKC_FEP_PVT.Create_Version(l_chr_id,l_major_version);
611: --- If any errors happen abort API
612: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
613: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
614: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
615: RAISE OKC_API.G_EXCEPTION_ERROR;
616: END IF;
617:
618: --version governances

Line 615: RAISE OKC_API.G_EXCEPTION_ERROR;

611: --- If any errors happen abort API
612: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
613: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
614: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
615: RAISE OKC_API.G_EXCEPTION_ERROR;
616: END IF;
617:
618: --version governances
619: l_return_status:=OKC_GVE_PVT.Create_Version(l_chr_id,l_major_version);

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

617:
618: --version governances
619: l_return_status:=OKC_GVE_PVT.Create_Version(l_chr_id,l_major_version);
620: --- If any errors happen abort API
621: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
622: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
623: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
624: RAISE OKC_API.G_EXCEPTION_ERROR;
625: END IF;

Line 622: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

618: --version governances
619: l_return_status:=OKC_GVE_PVT.Create_Version(l_chr_id,l_major_version);
620: --- If any errors happen abort API
621: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
622: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
623: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
624: RAISE OKC_API.G_EXCEPTION_ERROR;
625: END IF;
626:

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

619: l_return_status:=OKC_GVE_PVT.Create_Version(l_chr_id,l_major_version);
620: --- If any errors happen abort API
621: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
622: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
623: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
624: RAISE OKC_API.G_EXCEPTION_ERROR;
625: END IF;
626:
627:

Line 624: RAISE OKC_API.G_EXCEPTION_ERROR;

620: --- If any errors happen abort API
621: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
622: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
623: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
624: RAISE OKC_API.G_EXCEPTION_ERROR;
625: END IF;
626:
627:
628: ------VERSION_PRICE_ADJUSTMENTS

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

627:
628: ------VERSION_PRICE_ADJUSTMENTS
629: l_return_status:=OKC_PAT_PVT.Create_Version(l_chr_id,l_major_version);
630: --- If any errors happen abort API
631: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
632: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
633: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
634: RAISE OKC_API.G_EXCEPTION_ERROR;
635: END IF;

Line 632: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

628: ------VERSION_PRICE_ADJUSTMENTS
629: l_return_status:=OKC_PAT_PVT.Create_Version(l_chr_id,l_major_version);
630: --- If any errors happen abort API
631: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
632: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
633: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
634: RAISE OKC_API.G_EXCEPTION_ERROR;
635: END IF;
636:

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

629: l_return_status:=OKC_PAT_PVT.Create_Version(l_chr_id,l_major_version);
630: --- If any errors happen abort API
631: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
632: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
633: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
634: RAISE OKC_API.G_EXCEPTION_ERROR;
635: END IF;
636:
637: --VERSION_PRICE_ADJ_ASSOCS

Line 634: RAISE OKC_API.G_EXCEPTION_ERROR;

630: --- If any errors happen abort API
631: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
632: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
633: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
634: RAISE OKC_API.G_EXCEPTION_ERROR;
635: END IF;
636:
637: --VERSION_PRICE_ADJ_ASSOCS
638: l_return_status:=OKC_PAC_PVT.Create_Version(l_chr_id,l_major_version);

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

636:
637: --VERSION_PRICE_ADJ_ASSOCS
638: l_return_status:=OKC_PAC_PVT.Create_Version(l_chr_id,l_major_version);
639: --- If any errors happen abort API
640: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
641: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
642: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
643: RAISE OKC_API.G_EXCEPTION_ERROR;
644: END IF;

Line 641: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

637: --VERSION_PRICE_ADJ_ASSOCS
638: l_return_status:=OKC_PAC_PVT.Create_Version(l_chr_id,l_major_version);
639: --- If any errors happen abort API
640: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
641: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
642: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
643: RAISE OKC_API.G_EXCEPTION_ERROR;
644: END IF;
645:

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

638: l_return_status:=OKC_PAC_PVT.Create_Version(l_chr_id,l_major_version);
639: --- If any errors happen abort API
640: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
641: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
642: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
643: RAISE OKC_API.G_EXCEPTION_ERROR;
644: END IF;
645:
646:

Line 643: RAISE OKC_API.G_EXCEPTION_ERROR;

639: --- If any errors happen abort API
640: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
641: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
642: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
643: RAISE OKC_API.G_EXCEPTION_ERROR;
644: END IF;
645:
646:
647: --VERSION_PRICE_ADJ_ATTRIBS

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

646:
647: --VERSION_PRICE_ADJ_ATTRIBS
648: l_return_status:=OKC_PAA_PVT.Create_Version(l_chr_id,l_major_version);
649: --- If any errors happen abort API
650: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
651: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
652: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
653: RAISE OKC_API.G_EXCEPTION_ERROR;
654: END IF;

Line 651: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

647: --VERSION_PRICE_ADJ_ATTRIBS
648: l_return_status:=OKC_PAA_PVT.Create_Version(l_chr_id,l_major_version);
649: --- If any errors happen abort API
650: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
651: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
652: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
653: RAISE OKC_API.G_EXCEPTION_ERROR;
654: END IF;
655:

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

648: l_return_status:=OKC_PAA_PVT.Create_Version(l_chr_id,l_major_version);
649: --- If any errors happen abort API
650: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
651: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
652: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
653: RAISE OKC_API.G_EXCEPTION_ERROR;
654: END IF;
655:
656: --VERSION_PRICE_ATT_VALUES

Line 653: RAISE OKC_API.G_EXCEPTION_ERROR;

649: --- If any errors happen abort API
650: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
651: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
652: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
653: RAISE OKC_API.G_EXCEPTION_ERROR;
654: END IF;
655:
656: --VERSION_PRICE_ATT_VALUES
657: l_return_status:=OKC_PAV_PVT.Create_Version(l_chr_id,l_major_version);

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

655:
656: --VERSION_PRICE_ATT_VALUES
657: l_return_status:=OKC_PAV_PVT.Create_Version(l_chr_id,l_major_version);
658: --- If any errors happen abort API
659: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
660: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
661: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
662: RAISE OKC_API.G_EXCEPTION_ERROR;
663: END IF;

Line 660: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

656: --VERSION_PRICE_ATT_VALUES
657: l_return_status:=OKC_PAV_PVT.Create_Version(l_chr_id,l_major_version);
658: --- If any errors happen abort API
659: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
660: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
661: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
662: RAISE OKC_API.G_EXCEPTION_ERROR;
663: END IF;
664:

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

657: l_return_status:=OKC_PAV_PVT.Create_Version(l_chr_id,l_major_version);
658: --- If any errors happen abort API
659: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
660: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
661: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
662: RAISE OKC_API.G_EXCEPTION_ERROR;
663: END IF;
664:
665:

Line 662: RAISE OKC_API.G_EXCEPTION_ERROR;

658: --- If any errors happen abort API
659: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
660: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
661: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
662: RAISE OKC_API.G_EXCEPTION_ERROR;
663: END IF;
664:
665:
666: --VERSION SALES CREDITS

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

665:
666: --VERSION SALES CREDITS
667: l_return_status:=OKC_SCR_PVT.Create_Version(l_chr_id,l_major_version);
668: --- If any errors happen abort API
669: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
670: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
671: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
672: RAISE OKC_API.G_EXCEPTION_ERROR;
673: END IF;

Line 670: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

666: --VERSION SALES CREDITS
667: l_return_status:=OKC_SCR_PVT.Create_Version(l_chr_id,l_major_version);
668: --- If any errors happen abort API
669: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
670: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
671: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
672: RAISE OKC_API.G_EXCEPTION_ERROR;
673: END IF;
674:

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

667: l_return_status:=OKC_SCR_PVT.Create_Version(l_chr_id,l_major_version);
668: --- If any errors happen abort API
669: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
670: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
671: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
672: RAISE OKC_API.G_EXCEPTION_ERROR;
673: END IF;
674:
675:

Line 672: RAISE OKC_API.G_EXCEPTION_ERROR;

668: --- If any errors happen abort API
669: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
670: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
671: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
672: RAISE OKC_API.G_EXCEPTION_ERROR;
673: END IF;
674:
675:
676: --VERSION PRICE HOLD BREAK LINES

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

675:
676: --VERSION PRICE HOLD BREAK LINES
677: l_return_status:=OKC_PHL_PVT.Create_Version(l_chr_id,l_major_version);
678: --- If any errors happen abort API
679: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
680: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
681: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
682: RAISE OKC_API.G_EXCEPTION_ERROR;
683: END IF;

Line 680: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

676: --VERSION PRICE HOLD BREAK LINES
677: l_return_status:=OKC_PHL_PVT.Create_Version(l_chr_id,l_major_version);
678: --- If any errors happen abort API
679: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
680: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
681: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
682: RAISE OKC_API.G_EXCEPTION_ERROR;
683: END IF;
684:

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

677: l_return_status:=OKC_PHL_PVT.Create_Version(l_chr_id,l_major_version);
678: --- If any errors happen abort API
679: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
680: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
681: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
682: RAISE OKC_API.G_EXCEPTION_ERROR;
683: END IF;
684:
685:

Line 682: RAISE OKC_API.G_EXCEPTION_ERROR;

678: --- If any errors happen abort API
679: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
680: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
681: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
682: RAISE OKC_API.G_EXCEPTION_ERROR;
683: END IF;
684:
685:
686: --VERSION TERMS and Condition and Deliverables

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

694: x_doc_id => l_doc_id,
695: x_doc_type => l_doc_type);
696:
697: --- If any errors happen abort API
698: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
699: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
700: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
701: RAISE OKC_API.G_EXCEPTION_ERROR;
702: END IF;

Line 699: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

695: x_doc_type => l_doc_type);
696:
697: --- If any errors happen abort API
698: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
699: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
700: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
701: RAISE OKC_API.G_EXCEPTION_ERROR;
702: END IF;
703:

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

696:
697: --- If any errors happen abort API
698: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
699: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
700: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
701: RAISE OKC_API.G_EXCEPTION_ERROR;
702: END IF;
703:
704: OKC_TERMS_VERSION_GRP.Version_doc(

Line 701: RAISE OKC_API.G_EXCEPTION_ERROR;

697: --- If any errors happen abort API
698: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
699: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
700: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
701: RAISE OKC_API.G_EXCEPTION_ERROR;
702: END IF;
703:
704: OKC_TERMS_VERSION_GRP.Version_doc(
705: p_api_version => 1,

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

711: p_version_number =>l_major_version,
712: p_clear_amendment =>'Y');
713:
714: --- If any errors happen abort API
715: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
716: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
717: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
718: RAISE OKC_API.G_EXCEPTION_ERROR;
719: END IF;

Line 716: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

712: p_clear_amendment =>'Y');
713:
714: --- If any errors happen abort API
715: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
716: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
717: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
718: RAISE OKC_API.G_EXCEPTION_ERROR;
719: END IF;
720:

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

713:
714: --- If any errors happen abort API
715: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
716: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
717: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
718: RAISE OKC_API.G_EXCEPTION_ERROR;
719: END IF;
720:
721:

Line 718: RAISE OKC_API.G_EXCEPTION_ERROR;

714: --- If any errors happen abort API
715: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
716: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
717: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
718: RAISE OKC_API.G_EXCEPTION_ERROR;
719: END IF;
720:
721:
722:

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

719: END IF;
720:
721:
722:
723: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
724: x_cvmv_rec:=l_cvmv_rec;
725: x_return_status:=l_return_status;
726:
727: if (p_commit = OKC_API.G_TRUE) then commit; end if;

Line 727: if (p_commit = OKC_API.G_TRUE) then commit; end if;

723: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
724: x_cvmv_rec:=l_cvmv_rec;
725: x_return_status:=l_return_status;
726:
727: if (p_commit = OKC_API.G_TRUE) then commit; end if;
728:
729: EXCEPTION
730:
731: WHEN OKC_API.G_EXCEPTION_ERROR THEN

Line 731: WHEN OKC_API.G_EXCEPTION_ERROR THEN

727: if (p_commit = OKC_API.G_TRUE) then commit; end if;
728:
729: EXCEPTION
730:
731: WHEN OKC_API.G_EXCEPTION_ERROR THEN
732: x_return_status := OKC_API.HANDLE_EXCEPTIONS
733: (
734: l_api_name,
735: G_PKG_NAME,

Line 732: x_return_status := OKC_API.HANDLE_EXCEPTIONS

728:
729: EXCEPTION
730:
731: WHEN OKC_API.G_EXCEPTION_ERROR THEN
732: x_return_status := OKC_API.HANDLE_EXCEPTIONS
733: (
734: l_api_name,
735: G_PKG_NAME,
736: 'OKC_API.G_RET_STS_ERROR',

Line 736: 'OKC_API.G_RET_STS_ERROR',

732: x_return_status := OKC_API.HANDLE_EXCEPTIONS
733: (
734: l_api_name,
735: G_PKG_NAME,
736: 'OKC_API.G_RET_STS_ERROR',
737: x_msg_count,
738: x_msg_data,
739: '_PVT'
740: );

Line 741: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

737: x_msg_count,
738: x_msg_data,
739: '_PVT'
740: );
741: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
742: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
743: (
744: l_api_name,
745: G_PKG_NAME,

Line 742: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

738: x_msg_data,
739: '_PVT'
740: );
741: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
742: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
743: (
744: l_api_name,
745: G_PKG_NAME,
746: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 746: 'OKC_API.G_RET_STS_UNEXP_ERROR',

742: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
743: (
744: l_api_name,
745: G_PKG_NAME,
746: 'OKC_API.G_RET_STS_UNEXP_ERROR',
747: x_msg_count,
748: x_msg_data,
749: '_PVT'
750: );

Line 752: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

748: x_msg_data,
749: '_PVT'
750: );
751: WHEN OTHERS THEN
752: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
753: (
754: l_api_name,
755: G_PKG_NAME,
756: 'OTHERS',

Line 769: p_init_msg_list IN VARCHAR2 DEFAULT OKC_API.G_FALSE,

765:
766: PROCEDURE save_version(
767: p_chr_id IN NUMBER,
768: p_api_version IN NUMBER,
769: p_init_msg_list IN VARCHAR2 DEFAULT OKC_API.G_FALSE,
770: x_return_status OUT NOCOPY VARCHAR2,
771: x_msg_count OUT NOCOPY NUMBER,
772: x_msg_data OUT NOCOPY VARCHAR2,
773: p_commit IN VARCHAR2 DEFAULT OKC_API.G_TRUE) IS

Line 773: p_commit IN VARCHAR2 DEFAULT OKC_API.G_TRUE) IS

769: p_init_msg_list IN VARCHAR2 DEFAULT OKC_API.G_FALSE,
770: x_return_status OUT NOCOPY VARCHAR2,
771: x_msg_count OUT NOCOPY NUMBER,
772: x_msg_data OUT NOCOPY VARCHAR2,
773: p_commit IN VARCHAR2 DEFAULT OKC_API.G_TRUE) IS
774:
775:
776: l_api_version CONSTANT NUMBER := 1;
777: l_api_name CONSTANT VARCHAR2(30) := 'V_save_version';

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

774:
775:
776: l_api_version CONSTANT NUMBER := 1;
777: l_api_name CONSTANT VARCHAR2(30) := 'V_save_version';
778: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
779: l_major_version CONSTANT NUMBER := -1;
780: l_major_version2 CONSTANT NUMBER := -2;
781: l_chr_id NUMBER := p_chr_id;
782: l_code VARCHAR2(30);

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

799: l_dummy varchar2(1);
800:
801:
802: BEGIN
803: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
804: G_PKG_NAME,
805: p_init_msg_list,
806: l_api_version,
807: p_api_version,

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

806: l_api_version,
807: p_api_version,
808: '_PVT',
809: x_return_status);
810: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
811: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
812: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
813: RAISE OKC_API.G_EXCEPTION_ERROR;
814: END IF;

Line 811: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

807: p_api_version,
808: '_PVT',
809: x_return_status);
810: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
811: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
812: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
813: RAISE OKC_API.G_EXCEPTION_ERROR;
814: END IF;
815:

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

808: '_PVT',
809: x_return_status);
810: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
811: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
812: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
813: RAISE OKC_API.G_EXCEPTION_ERROR;
814: END IF;
815:
816: begin

Line 813: RAISE OKC_API.G_EXCEPTION_ERROR;

809: x_return_status);
810: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
811: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
812: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
813: RAISE OKC_API.G_EXCEPTION_ERROR;
814: END IF;
815:
816: begin
817: open v_lock;

Line 822: OKC_API.set_message(OKC_API.G_FND_APP,OKC_API.G_FORM_UNABLE_TO_RESERVE_REC);

818: fetch v_lock into l_dummy;
819: close v_lock;
820: exception
821: when others then
822: OKC_API.set_message(OKC_API.G_FND_APP,OKC_API.G_FORM_UNABLE_TO_RESERVE_REC);
823: RAISE OKC_API.G_EXCEPTION_ERROR;
824: end;
825:
826: -- Version Attachments SAVE_VERSION

Line 823: RAISE OKC_API.G_EXCEPTION_ERROR;

819: close v_lock;
820: exception
821: when others then
822: OKC_API.set_message(OKC_API.G_FND_APP,OKC_API.G_FORM_UNABLE_TO_RESERVE_REC);
823: RAISE OKC_API.G_EXCEPTION_ERROR;
824: end;
825:
826: -- Version Attachments SAVE_VERSION
827: --

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

838: p_api_version => p_api_version,
839: x_return_status =>l_return_status,
840: x_msg_count =>x_msg_count,
841: x_msg_data =>x_msg_data);
842: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
843: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
844: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
845: RAISE OKC_API.G_EXCEPTION_ERROR;
846: END IF;

Line 843: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

839: x_return_status =>l_return_status,
840: x_msg_count =>x_msg_count,
841: x_msg_data =>x_msg_data);
842: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
843: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
844: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
845: RAISE OKC_API.G_EXCEPTION_ERROR;
846: END IF;
847: END IF;

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

840: x_msg_count =>x_msg_count,
841: x_msg_data =>x_msg_data);
842: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
843: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
844: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
845: RAISE OKC_API.G_EXCEPTION_ERROR;
846: END IF;
847: END IF;
848: --

Line 845: RAISE OKC_API.G_EXCEPTION_ERROR;

841: x_msg_data =>x_msg_data);
842: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
843: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
844: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
845: RAISE OKC_API.G_EXCEPTION_ERROR;
846: END IF;
847: END IF;
848: --
849: erase_saved_version(

Line 856: p_commit => OKC_API.G_FALSE);

852: p_init_msg_list => p_init_msg_list,
853: x_return_status => l_return_status,
854: x_msg_count => x_msg_count,
855: x_msg_data => x_msg_data,
856: p_commit => OKC_API.G_FALSE);
857: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
858: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
859: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
860: RAISE OKC_API.G_EXCEPTION_ERROR;

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

853: x_return_status => l_return_status,
854: x_msg_count => x_msg_count,
855: x_msg_data => x_msg_data,
856: p_commit => OKC_API.G_FALSE);
857: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
858: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
859: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
860: RAISE OKC_API.G_EXCEPTION_ERROR;
861: END IF;

Line 858: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

854: x_msg_count => x_msg_count,
855: x_msg_data => x_msg_data,
856: p_commit => OKC_API.G_FALSE);
857: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
858: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
859: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
860: RAISE OKC_API.G_EXCEPTION_ERROR;
861: END IF;
862:

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

855: x_msg_data => x_msg_data,
856: p_commit => OKC_API.G_FALSE);
857: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
858: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
859: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
860: RAISE OKC_API.G_EXCEPTION_ERROR;
861: END IF;
862:
863: --version contract header

Line 860: RAISE OKC_API.G_EXCEPTION_ERROR;

856: p_commit => OKC_API.G_FALSE);
857: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
858: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
859: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
860: RAISE OKC_API.G_EXCEPTION_ERROR;
861: END IF;
862:
863: --version contract header
864:

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

865: IF FND_PROFILE.VALUE_SPECIFIC('OKC_REVERT_OPTION') <> 'ALLOW' AND l_code<>'SERVICE' THEN
866: l_return_status:=OKC_CHR_PVT.Create_Version(l_chr_id,l_major_version2);
867:
868: --- If any errors happen abort API
869: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
870: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
871: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
872: RAISE OKC_API.G_EXCEPTION_ERROR;
873: END IF;

Line 870: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

866: l_return_status:=OKC_CHR_PVT.Create_Version(l_chr_id,l_major_version2);
867:
868: --- If any errors happen abort API
869: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
870: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
871: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
872: RAISE OKC_API.G_EXCEPTION_ERROR;
873: END IF;
874:

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

867:
868: --- If any errors happen abort API
869: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
870: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
871: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
872: RAISE OKC_API.G_EXCEPTION_ERROR;
873: END IF;
874:
875: ELSE

Line 872: RAISE OKC_API.G_EXCEPTION_ERROR;

868: --- If any errors happen abort API
869: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
870: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
871: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
872: RAISE OKC_API.G_EXCEPTION_ERROR;
873: END IF;
874:
875: ELSE
876:

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

875: ELSE
876:
877: l_return_status:=OKC_CHR_PVT.Create_Version(l_chr_id,l_major_version);
878: --- If any errors happen abort API
879: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
880: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
881: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
882: RAISE OKC_API.G_EXCEPTION_ERROR;
883: END IF;

Line 880: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

876:
877: l_return_status:=OKC_CHR_PVT.Create_Version(l_chr_id,l_major_version);
878: --- If any errors happen abort API
879: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
880: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
881: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
882: RAISE OKC_API.G_EXCEPTION_ERROR;
883: END IF;
884:

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

877: l_return_status:=OKC_CHR_PVT.Create_Version(l_chr_id,l_major_version);
878: --- If any errors happen abort API
879: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
880: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
881: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
882: RAISE OKC_API.G_EXCEPTION_ERROR;
883: END IF;
884:
885: --version contract lines

Line 882: RAISE OKC_API.G_EXCEPTION_ERROR;

878: --- If any errors happen abort API
879: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
880: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
881: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
882: RAISE OKC_API.G_EXCEPTION_ERROR;
883: END IF;
884:
885: --version contract lines
886:

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

885: --version contract lines
886:
887: l_return_status:=OKC_CLE_PVT.Create_Version(l_chr_id,l_major_version);
888: --- If any errors happen abort API
889: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
890: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
891: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
892: RAISE OKC_API.G_EXCEPTION_ERROR;
893: END IF;

Line 890: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

886:
887: l_return_status:=OKC_CLE_PVT.Create_Version(l_chr_id,l_major_version);
888: --- If any errors happen abort API
889: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
890: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
891: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
892: RAISE OKC_API.G_EXCEPTION_ERROR;
893: END IF;
894:

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

887: l_return_status:=OKC_CLE_PVT.Create_Version(l_chr_id,l_major_version);
888: --- If any errors happen abort API
889: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
890: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
891: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
892: RAISE OKC_API.G_EXCEPTION_ERROR;
893: END IF;
894:
895: --version contract items

Line 892: RAISE OKC_API.G_EXCEPTION_ERROR;

888: --- If any errors happen abort API
889: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
890: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
891: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
892: RAISE OKC_API.G_EXCEPTION_ERROR;
893: END IF;
894:
895: --version contract items
896: l_return_status:=OKC_CIM_PVT.Create_Version(l_chr_id,l_major_version);

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

894:
895: --version contract items
896: l_return_status:=OKC_CIM_PVT.Create_Version(l_chr_id,l_major_version);
897: --- If any errors happen abort API
898: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
899: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
900: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
901: RAISE OKC_API.G_EXCEPTION_ERROR;
902: END IF;

Line 899: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

895: --version contract items
896: l_return_status:=OKC_CIM_PVT.Create_Version(l_chr_id,l_major_version);
897: --- If any errors happen abort API
898: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
899: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
900: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
901: RAISE OKC_API.G_EXCEPTION_ERROR;
902: END IF;
903:

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

896: l_return_status:=OKC_CIM_PVT.Create_Version(l_chr_id,l_major_version);
897: --- If any errors happen abort API
898: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
899: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
900: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
901: RAISE OKC_API.G_EXCEPTION_ERROR;
902: END IF;
903:
904: --version contract party roles

Line 901: RAISE OKC_API.G_EXCEPTION_ERROR;

897: --- If any errors happen abort API
898: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
899: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
900: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
901: RAISE OKC_API.G_EXCEPTION_ERROR;
902: END IF;
903:
904: --version contract party roles
905: l_return_status:=OKC_CPL_PVT.Create_Version(l_chr_id,l_major_version);

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

903:
904: --version contract party roles
905: l_return_status:=OKC_CPL_PVT.Create_Version(l_chr_id,l_major_version);
906: --- If any errors happen abort API
907: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
908: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
909: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
910: RAISE OKC_API.G_EXCEPTION_ERROR;
911: END IF;

Line 908: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

904: --version contract party roles
905: l_return_status:=OKC_CPL_PVT.Create_Version(l_chr_id,l_major_version);
906: --- If any errors happen abort API
907: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
908: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
909: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
910: RAISE OKC_API.G_EXCEPTION_ERROR;
911: END IF;
912:

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

905: l_return_status:=OKC_CPL_PVT.Create_Version(l_chr_id,l_major_version);
906: --- If any errors happen abort API
907: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
908: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
909: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
910: RAISE OKC_API.G_EXCEPTION_ERROR;
911: END IF;
912:
913: --version RuleGroup party roles

Line 910: RAISE OKC_API.G_EXCEPTION_ERROR;

906: --- If any errors happen abort API
907: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
908: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
909: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
910: RAISE OKC_API.G_EXCEPTION_ERROR;
911: END IF;
912:
913: --version RuleGroup party roles
914: l_return_status:=OKC_RMP_PVT.Create_Version(l_chr_id,l_major_version);

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

912:
913: --version RuleGroup party roles
914: l_return_status:=OKC_RMP_PVT.Create_Version(l_chr_id,l_major_version);
915: --- If any errors happen abort API
916: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
917: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
918: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
919: RAISE OKC_API.G_EXCEPTION_ERROR;
920: END IF;

Line 917: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

913: --version RuleGroup party roles
914: l_return_status:=OKC_RMP_PVT.Create_Version(l_chr_id,l_major_version);
915: --- If any errors happen abort API
916: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
917: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
918: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
919: RAISE OKC_API.G_EXCEPTION_ERROR;
920: END IF;
921:

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

914: l_return_status:=OKC_RMP_PVT.Create_Version(l_chr_id,l_major_version);
915: --- If any errors happen abort API
916: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
917: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
918: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
919: RAISE OKC_API.G_EXCEPTION_ERROR;
920: END IF;
921:
922: --version Rule Groups

Line 919: RAISE OKC_API.G_EXCEPTION_ERROR;

915: --- If any errors happen abort API
916: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
917: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
918: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
919: RAISE OKC_API.G_EXCEPTION_ERROR;
920: END IF;
921:
922: --version Rule Groups
923: l_return_status:=OKC_RGP_PVT.Create_Version(l_chr_id,l_major_version);

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

921:
922: --version Rule Groups
923: l_return_status:=OKC_RGP_PVT.Create_Version(l_chr_id,l_major_version);
924: --- If any errors happen abort API
925: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
926: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
927: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
928: RAISE OKC_API.G_EXCEPTION_ERROR;
929: END IF;

Line 926: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

922: --version Rule Groups
923: l_return_status:=OKC_RGP_PVT.Create_Version(l_chr_id,l_major_version);
924: --- If any errors happen abort API
925: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
926: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
927: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
928: RAISE OKC_API.G_EXCEPTION_ERROR;
929: END IF;
930:

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

923: l_return_status:=OKC_RGP_PVT.Create_Version(l_chr_id,l_major_version);
924: --- If any errors happen abort API
925: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
926: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
927: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
928: RAISE OKC_API.G_EXCEPTION_ERROR;
929: END IF;
930:
931: --version Rules

Line 928: RAISE OKC_API.G_EXCEPTION_ERROR;

924: --- If any errors happen abort API
925: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
926: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
927: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
928: RAISE OKC_API.G_EXCEPTION_ERROR;
929: END IF;
930:
931: --version Rules
932: l_return_status:=OKC_RUL_PVT.Create_Version(l_chr_id,l_major_version);

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

930:
931: --version Rules
932: l_return_status:=OKC_RUL_PVT.Create_Version(l_chr_id,l_major_version);
933: --- If any errors happen abort API
934: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
935: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
936: ELSIF (l_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: --version Rules
932: l_return_status:=OKC_RUL_PVT.Create_Version(l_chr_id,l_major_version);
933: --- If any errors happen abort API
934: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
935: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
936: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
937: RAISE OKC_API.G_EXCEPTION_ERROR;
938: END IF;
939:

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

932: l_return_status:=OKC_RUL_PVT.Create_Version(l_chr_id,l_major_version);
933: --- If any errors happen abort API
934: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
935: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
936: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
937: RAISE OKC_API.G_EXCEPTION_ERROR;
938: END IF;
939:
940: --version Contacts

Line 937: RAISE OKC_API.G_EXCEPTION_ERROR;

933: --- If any errors happen abort API
934: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
935: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
936: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
937: RAISE OKC_API.G_EXCEPTION_ERROR;
938: END IF;
939:
940: --version Contacts
941: l_return_status:=OKC_CTC_PVT.Create_Version(l_chr_id,l_major_version);

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

939:
940: --version Contacts
941: l_return_status:=OKC_CTC_PVT.Create_Version(l_chr_id,l_major_version);
942: --- If any errors happen abort API
943: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
944: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
945: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
946: RAISE OKC_API.G_EXCEPTION_ERROR;
947: END IF;

Line 944: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

940: --version Contacts
941: l_return_status:=OKC_CTC_PVT.Create_Version(l_chr_id,l_major_version);
942: --- If any errors happen abort API
943: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
944: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
945: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
946: RAISE OKC_API.G_EXCEPTION_ERROR;
947: END IF;
948:

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

941: l_return_status:=OKC_CTC_PVT.Create_Version(l_chr_id,l_major_version);
942: --- If any errors happen abort API
943: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
944: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
945: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
946: RAISE OKC_API.G_EXCEPTION_ERROR;
947: END IF;
948:
949: --version cover times

Line 946: RAISE OKC_API.G_EXCEPTION_ERROR;

942: --- If any errors happen abort API
943: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
944: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
945: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
946: RAISE OKC_API.G_EXCEPTION_ERROR;
947: END IF;
948:
949: --version cover times
950: l_return_status:=OKC_CTI_PVT.Create_Version(l_chr_id,l_major_version);

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

948:
949: --version cover times
950: l_return_status:=OKC_CTI_PVT.Create_Version(l_chr_id,l_major_version);
951: --- If any errors happen abort API
952: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
953: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
954: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
955: RAISE OKC_API.G_EXCEPTION_ERROR;
956: END IF;

Line 953: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

949: --version cover times
950: l_return_status:=OKC_CTI_PVT.Create_Version(l_chr_id,l_major_version);
951: --- If any errors happen abort API
952: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
953: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
954: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
955: RAISE OKC_API.G_EXCEPTION_ERROR;
956: END IF;
957:

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

950: l_return_status:=OKC_CTI_PVT.Create_Version(l_chr_id,l_major_version);
951: --- If any errors happen abort API
952: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
953: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
954: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
955: RAISE OKC_API.G_EXCEPTION_ERROR;
956: END IF;
957:
958: --version contract accesses

Line 955: RAISE OKC_API.G_EXCEPTION_ERROR;

951: --- If any errors happen abort API
952: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
953: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
954: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
955: RAISE OKC_API.G_EXCEPTION_ERROR;
956: END IF;
957:
958: --version contract accesses
959: l_return_status:=OKC_CAC_PVT.Create_Version(l_chr_id,l_major_version);

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

957:
958: --version contract accesses
959: l_return_status:=OKC_CAC_PVT.Create_Version(l_chr_id,l_major_version);
960: --- If any errors happen abort API
961: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
962: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
963: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
964: RAISE OKC_API.G_EXCEPTION_ERROR;
965: END IF;

Line 962: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

958: --version contract accesses
959: l_return_status:=OKC_CAC_PVT.Create_Version(l_chr_id,l_major_version);
960: --- If any errors happen abort API
961: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
962: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
963: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
964: RAISE OKC_API.G_EXCEPTION_ERROR;
965: END IF;
966:

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

959: l_return_status:=OKC_CAC_PVT.Create_Version(l_chr_id,l_major_version);
960: --- If any errors happen abort API
961: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
962: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
963: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
964: RAISE OKC_API.G_EXCEPTION_ERROR;
965: END IF;
966:
967: --version outcome arguments

Line 964: RAISE OKC_API.G_EXCEPTION_ERROR;

960: --- If any errors happen abort API
961: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
962: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
963: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
964: RAISE OKC_API.G_EXCEPTION_ERROR;
965: END IF;
966:
967: --version outcome arguments
968: l_return_status:=OKC_OAT_PVT.Create_Version(l_chr_id,l_major_version);

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

966:
967: --version outcome arguments
968: l_return_status:=OKC_OAT_PVT.Create_Version(l_chr_id,l_major_version);
969: --- If any errors happen abort API
970: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
971: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
972: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
973: RAISE OKC_API.G_EXCEPTION_ERROR;
974: END IF;

Line 971: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

967: --version outcome arguments
968: l_return_status:=OKC_OAT_PVT.Create_Version(l_chr_id,l_major_version);
969: --- If any errors happen abort API
970: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
971: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
972: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
973: RAISE OKC_API.G_EXCEPTION_ERROR;
974: END IF;
975:

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

968: l_return_status:=OKC_OAT_PVT.Create_Version(l_chr_id,l_major_version);
969: --- If any errors happen abort API
970: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
971: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
972: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
973: RAISE OKC_API.G_EXCEPTION_ERROR;
974: END IF;
975:
976: --version outcomes

Line 973: RAISE OKC_API.G_EXCEPTION_ERROR;

969: --- If any errors happen abort API
970: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
971: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
972: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
973: RAISE OKC_API.G_EXCEPTION_ERROR;
974: END IF;
975:
976: --version outcomes
977: l_return_status:=OKC_OCE_PVT.Create_Version(l_chr_id,l_major_version);

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

975:
976: --version outcomes
977: l_return_status:=OKC_OCE_PVT.Create_Version(l_chr_id,l_major_version);
978: --- If any errors happen abort API
979: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
980: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
981: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
982: RAISE OKC_API.G_EXCEPTION_ERROR;
983: END IF;

Line 980: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

976: --version outcomes
977: l_return_status:=OKC_OCE_PVT.Create_Version(l_chr_id,l_major_version);
978: --- If any errors happen abort API
979: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
980: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
981: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
982: RAISE OKC_API.G_EXCEPTION_ERROR;
983: END IF;
984:

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

977: l_return_status:=OKC_OCE_PVT.Create_Version(l_chr_id,l_major_version);
978: --- If any errors happen abort API
979: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
980: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
981: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
982: RAISE OKC_API.G_EXCEPTION_ERROR;
983: END IF;
984:
985: --version react intervals

Line 982: RAISE OKC_API.G_EXCEPTION_ERROR;

978: --- If any errors happen abort API
979: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
980: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
981: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
982: RAISE OKC_API.G_EXCEPTION_ERROR;
983: END IF;
984:
985: --version react intervals
986: l_return_status:=OKC_RIL_PVT.Create_Version(l_chr_id,l_major_version);

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

984:
985: --version react intervals
986: l_return_status:=OKC_RIL_PVT.Create_Version(l_chr_id,l_major_version);
987: --- If any errors happen abort API
988: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
989: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
990: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
991: RAISE OKC_API.G_EXCEPTION_ERROR;
992: END IF;

Line 989: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

985: --version react intervals
986: l_return_status:=OKC_RIL_PVT.Create_Version(l_chr_id,l_major_version);
987: --- If any errors happen abort API
988: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
989: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
990: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
991: RAISE OKC_API.G_EXCEPTION_ERROR;
992: END IF;
993:

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

986: l_return_status:=OKC_RIL_PVT.Create_Version(l_chr_id,l_major_version);
987: --- If any errors happen abort API
988: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
989: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
990: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
991: RAISE OKC_API.G_EXCEPTION_ERROR;
992: END IF;
993:
994:

Line 991: RAISE OKC_API.G_EXCEPTION_ERROR;

987: --- If any errors happen abort API
988: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
989: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
990: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
991: RAISE OKC_API.G_EXCEPTION_ERROR;
992: END IF;
993:
994:
995: --version timevalues

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

994:
995: --version timevalues
996: l_return_status:=OKC_TAV_PVT.Create_Version(l_chr_id,l_major_version);
997: --- If any errors happen abort API
998: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
999: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1000: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1001: RAISE OKC_API.G_EXCEPTION_ERROR;
1002: END IF;

Line 999: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

995: --version timevalues
996: l_return_status:=OKC_TAV_PVT.Create_Version(l_chr_id,l_major_version);
997: --- If any errors happen abort API
998: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
999: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1000: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1001: RAISE OKC_API.G_EXCEPTION_ERROR;
1002: END IF;
1003:

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

996: l_return_status:=OKC_TAV_PVT.Create_Version(l_chr_id,l_major_version);
997: --- If any errors happen abort API
998: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
999: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1000: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1001: RAISE OKC_API.G_EXCEPTION_ERROR;
1002: END IF;
1003:
1004: --version contract processes

Line 1001: RAISE OKC_API.G_EXCEPTION_ERROR;

997: --- If any errors happen abort API
998: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
999: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1000: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1001: RAISE OKC_API.G_EXCEPTION_ERROR;
1002: END IF;
1003:
1004: --version contract processes
1005: l_return_status:=OKC_CPS_PVT.Create_Version(l_chr_id,l_major_version);

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

1003:
1004: --version contract processes
1005: l_return_status:=OKC_CPS_PVT.Create_Version(l_chr_id,l_major_version);
1006: --- If any errors happen abort API
1007: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1008: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1009: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1010: RAISE OKC_API.G_EXCEPTION_ERROR;
1011: END IF;

Line 1008: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1004: --version contract processes
1005: l_return_status:=OKC_CPS_PVT.Create_Version(l_chr_id,l_major_version);
1006: --- If any errors happen abort API
1007: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1008: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1009: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1010: RAISE OKC_API.G_EXCEPTION_ERROR;
1011: END IF;
1012:

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

1005: l_return_status:=OKC_CPS_PVT.Create_Version(l_chr_id,l_major_version);
1006: --- If any errors happen abort API
1007: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1008: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1009: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1010: RAISE OKC_API.G_EXCEPTION_ERROR;
1011: END IF;
1012:
1013: --version condition headers

Line 1010: RAISE OKC_API.G_EXCEPTION_ERROR;

1006: --- If any errors happen abort API
1007: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1008: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1009: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1010: RAISE OKC_API.G_EXCEPTION_ERROR;
1011: END IF;
1012:
1013: --version condition headers
1014: l_return_status:=OKC_CNH_PVT.Create_Version(l_chr_id,l_major_version);

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

1012:
1013: --version condition headers
1014: l_return_status:=OKC_CNH_PVT.Create_Version(l_chr_id,l_major_version);
1015: --- If any errors happen abort API
1016: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1017: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1018: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1019: RAISE OKC_API.G_EXCEPTION_ERROR;
1020: END IF;

Line 1017: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1013: --version condition headers
1014: l_return_status:=OKC_CNH_PVT.Create_Version(l_chr_id,l_major_version);
1015: --- If any errors happen abort API
1016: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1017: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1018: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1019: RAISE OKC_API.G_EXCEPTION_ERROR;
1020: END IF;
1021:

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

1014: l_return_status:=OKC_CNH_PVT.Create_Version(l_chr_id,l_major_version);
1015: --- If any errors happen abort API
1016: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1017: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1018: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1019: RAISE OKC_API.G_EXCEPTION_ERROR;
1020: END IF;
1021:
1022:

Line 1019: RAISE OKC_API.G_EXCEPTION_ERROR;

1015: --- If any errors happen abort API
1016: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1017: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1018: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1019: RAISE OKC_API.G_EXCEPTION_ERROR;
1020: END IF;
1021:
1022:
1023: --version condition lines

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

1022:
1023: --version condition lines
1024: l_return_status:=OKC_CNL_PVT.Create_Version(l_chr_id,l_major_version);
1025: --- If any errors happen abort API
1026: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1027: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1028: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1029: RAISE OKC_API.G_EXCEPTION_ERROR;
1030: END IF;

Line 1027: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1023: --version condition lines
1024: l_return_status:=OKC_CNL_PVT.Create_Version(l_chr_id,l_major_version);
1025: --- If any errors happen abort API
1026: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1027: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1028: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1029: RAISE OKC_API.G_EXCEPTION_ERROR;
1030: END IF;
1031:

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

1024: l_return_status:=OKC_CNL_PVT.Create_Version(l_chr_id,l_major_version);
1025: --- If any errors happen abort API
1026: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1027: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1028: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1029: RAISE OKC_API.G_EXCEPTION_ERROR;
1030: END IF;
1031:
1032: --version function_expr_params

Line 1029: RAISE OKC_API.G_EXCEPTION_ERROR;

1025: --- If any errors happen abort API
1026: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1027: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1028: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1029: RAISE OKC_API.G_EXCEPTION_ERROR;
1030: END IF;
1031:
1032: --version function_expr_params
1033: l_return_status:=OKC_FEP_PVT.Create_Version(l_chr_id,l_major_version);

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

1031:
1032: --version function_expr_params
1033: l_return_status:=OKC_FEP_PVT.Create_Version(l_chr_id,l_major_version);
1034: --- If any errors happen abort API
1035: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1036: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1037: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1038: RAISE OKC_API.G_EXCEPTION_ERROR;
1039: END IF;

Line 1036: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1032: --version function_expr_params
1033: l_return_status:=OKC_FEP_PVT.Create_Version(l_chr_id,l_major_version);
1034: --- If any errors happen abort API
1035: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1036: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1037: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1038: RAISE OKC_API.G_EXCEPTION_ERROR;
1039: END IF;
1040:

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

1033: l_return_status:=OKC_FEP_PVT.Create_Version(l_chr_id,l_major_version);
1034: --- If any errors happen abort API
1035: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1036: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1037: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1038: RAISE OKC_API.G_EXCEPTION_ERROR;
1039: END IF;
1040:
1041: --version governances

Line 1038: RAISE OKC_API.G_EXCEPTION_ERROR;

1034: --- If any errors happen abort API
1035: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1036: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1037: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1038: RAISE OKC_API.G_EXCEPTION_ERROR;
1039: END IF;
1040:
1041: --version governances
1042: l_return_status:=OKC_GVE_PVT.Create_Version(l_chr_id,l_major_version);

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

1040:
1041: --version governances
1042: l_return_status:=OKC_GVE_PVT.Create_Version(l_chr_id,l_major_version);
1043: --- If any errors happen abort API
1044: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1045: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1046: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1047: RAISE OKC_API.G_EXCEPTION_ERROR;
1048: END IF;

Line 1045: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1041: --version governances
1042: l_return_status:=OKC_GVE_PVT.Create_Version(l_chr_id,l_major_version);
1043: --- If any errors happen abort API
1044: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1045: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1046: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1047: RAISE OKC_API.G_EXCEPTION_ERROR;
1048: END IF;
1049:

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

1042: l_return_status:=OKC_GVE_PVT.Create_Version(l_chr_id,l_major_version);
1043: --- If any errors happen abort API
1044: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1045: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1046: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1047: RAISE OKC_API.G_EXCEPTION_ERROR;
1048: END IF;
1049:
1050: ------VERSION_PRICE_ADJUSTMENTS

Line 1047: RAISE OKC_API.G_EXCEPTION_ERROR;

1043: --- If any errors happen abort API
1044: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1045: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1046: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1047: RAISE OKC_API.G_EXCEPTION_ERROR;
1048: END IF;
1049:
1050: ------VERSION_PRICE_ADJUSTMENTS
1051: l_return_status:=OKC_PAT_PVT.Create_Version(l_chr_id,l_major_version);

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

1049:
1050: ------VERSION_PRICE_ADJUSTMENTS
1051: l_return_status:=OKC_PAT_PVT.Create_Version(l_chr_id,l_major_version);
1052: --- If any errors happen abort API
1053: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1054: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1055: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1056: RAISE OKC_API.G_EXCEPTION_ERROR;
1057: END IF;

Line 1054: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1050: ------VERSION_PRICE_ADJUSTMENTS
1051: l_return_status:=OKC_PAT_PVT.Create_Version(l_chr_id,l_major_version);
1052: --- If any errors happen abort API
1053: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1054: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1055: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1056: RAISE OKC_API.G_EXCEPTION_ERROR;
1057: END IF;
1058:

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

1051: l_return_status:=OKC_PAT_PVT.Create_Version(l_chr_id,l_major_version);
1052: --- If any errors happen abort API
1053: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1054: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1055: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1056: RAISE OKC_API.G_EXCEPTION_ERROR;
1057: END IF;
1058:
1059: --VERSION_PRICE_ADJ_ASSOCS

Line 1056: RAISE OKC_API.G_EXCEPTION_ERROR;

1052: --- If any errors happen abort API
1053: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1054: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1055: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1056: RAISE OKC_API.G_EXCEPTION_ERROR;
1057: END IF;
1058:
1059: --VERSION_PRICE_ADJ_ASSOCS
1060: l_return_status:=OKC_PAC_PVT.Create_Version(l_chr_id,l_major_version);

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

1058:
1059: --VERSION_PRICE_ADJ_ASSOCS
1060: l_return_status:=OKC_PAC_PVT.Create_Version(l_chr_id,l_major_version);
1061: --- If any errors happen abort API
1062: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1063: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1064: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1065: RAISE OKC_API.G_EXCEPTION_ERROR;
1066: END IF;

Line 1063: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1059: --VERSION_PRICE_ADJ_ASSOCS
1060: l_return_status:=OKC_PAC_PVT.Create_Version(l_chr_id,l_major_version);
1061: --- If any errors happen abort API
1062: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1063: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1064: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1065: RAISE OKC_API.G_EXCEPTION_ERROR;
1066: END IF;
1067:

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

1060: l_return_status:=OKC_PAC_PVT.Create_Version(l_chr_id,l_major_version);
1061: --- If any errors happen abort API
1062: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1063: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1064: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1065: RAISE OKC_API.G_EXCEPTION_ERROR;
1066: END IF;
1067:
1068:

Line 1065: RAISE OKC_API.G_EXCEPTION_ERROR;

1061: --- If any errors happen abort API
1062: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1063: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1064: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1065: RAISE OKC_API.G_EXCEPTION_ERROR;
1066: END IF;
1067:
1068:
1069: --VERSION_PRICE_ADJ_ATTRIBS

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

1068:
1069: --VERSION_PRICE_ADJ_ATTRIBS
1070: l_return_status:=OKC_PAA_PVT.Create_Version(l_chr_id,l_major_version);
1071: --- If any errors happen abort API
1072: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1073: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1074: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1075: RAISE OKC_API.G_EXCEPTION_ERROR;
1076: END IF;

Line 1073: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1069: --VERSION_PRICE_ADJ_ATTRIBS
1070: l_return_status:=OKC_PAA_PVT.Create_Version(l_chr_id,l_major_version);
1071: --- If any errors happen abort API
1072: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1073: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1074: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1075: RAISE OKC_API.G_EXCEPTION_ERROR;
1076: END IF;
1077:

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

1070: l_return_status:=OKC_PAA_PVT.Create_Version(l_chr_id,l_major_version);
1071: --- If any errors happen abort API
1072: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1073: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1074: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1075: RAISE OKC_API.G_EXCEPTION_ERROR;
1076: END IF;
1077:
1078: --VERSION_PRICE_ATT_VALUES

Line 1075: RAISE OKC_API.G_EXCEPTION_ERROR;

1071: --- If any errors happen abort API
1072: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1073: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1074: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1075: RAISE OKC_API.G_EXCEPTION_ERROR;
1076: END IF;
1077:
1078: --VERSION_PRICE_ATT_VALUES
1079: l_return_status:=OKC_PAV_PVT.Create_Version(l_chr_id,l_major_version);

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

1077:
1078: --VERSION_PRICE_ATT_VALUES
1079: l_return_status:=OKC_PAV_PVT.Create_Version(l_chr_id,l_major_version);
1080: --- If any errors happen abort API
1081: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1082: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1083: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1084: RAISE OKC_API.G_EXCEPTION_ERROR;
1085: END IF;

Line 1082: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1078: --VERSION_PRICE_ATT_VALUES
1079: l_return_status:=OKC_PAV_PVT.Create_Version(l_chr_id,l_major_version);
1080: --- If any errors happen abort API
1081: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1082: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1083: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1084: RAISE OKC_API.G_EXCEPTION_ERROR;
1085: END IF;
1086:

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

1079: l_return_status:=OKC_PAV_PVT.Create_Version(l_chr_id,l_major_version);
1080: --- If any errors happen abort API
1081: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1082: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1083: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1084: RAISE OKC_API.G_EXCEPTION_ERROR;
1085: END IF;
1086:
1087:

Line 1084: RAISE OKC_API.G_EXCEPTION_ERROR;

1080: --- If any errors happen abort API
1081: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1082: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1083: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1084: RAISE OKC_API.G_EXCEPTION_ERROR;
1085: END IF;
1086:
1087:
1088: --VERSION SALES CREDITS

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

1087:
1088: --VERSION SALES CREDITS
1089: l_return_status:=OKC_SCR_PVT.Create_Version(l_chr_id,l_major_version);
1090: --- If any errors happen abort API
1091: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1092: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1093: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1094: RAISE OKC_API.G_EXCEPTION_ERROR;
1095: END IF;

Line 1092: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1088: --VERSION SALES CREDITS
1089: l_return_status:=OKC_SCR_PVT.Create_Version(l_chr_id,l_major_version);
1090: --- If any errors happen abort API
1091: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1092: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1093: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1094: RAISE OKC_API.G_EXCEPTION_ERROR;
1095: END IF;
1096:

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

1089: l_return_status:=OKC_SCR_PVT.Create_Version(l_chr_id,l_major_version);
1090: --- If any errors happen abort API
1091: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1092: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1093: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1094: RAISE OKC_API.G_EXCEPTION_ERROR;
1095: END IF;
1096:
1097:

Line 1094: RAISE OKC_API.G_EXCEPTION_ERROR;

1090: --- If any errors happen abort API
1091: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1092: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1093: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1094: RAISE OKC_API.G_EXCEPTION_ERROR;
1095: END IF;
1096:
1097:
1098: --VERSION PRICE HOLD BREAK LINES

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

1097:
1098: --VERSION PRICE HOLD BREAK LINES
1099: l_return_status:=OKC_PHL_PVT.Create_Version(l_chr_id,l_major_version);
1100: --- If any errors happen abort API
1101: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1102: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1103: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1104: RAISE OKC_API.G_EXCEPTION_ERROR;
1105: END IF;

Line 1102: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1098: --VERSION PRICE HOLD BREAK LINES
1099: l_return_status:=OKC_PHL_PVT.Create_Version(l_chr_id,l_major_version);
1100: --- If any errors happen abort API
1101: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1102: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1103: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1104: RAISE OKC_API.G_EXCEPTION_ERROR;
1105: END IF;
1106:

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

1099: l_return_status:=OKC_PHL_PVT.Create_Version(l_chr_id,l_major_version);
1100: --- If any errors happen abort API
1101: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1102: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1103: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1104: RAISE OKC_API.G_EXCEPTION_ERROR;
1105: END IF;
1106:
1107:

Line 1104: RAISE OKC_API.G_EXCEPTION_ERROR;

1100: --- If any errors happen abort API
1101: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1102: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1103: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1104: RAISE OKC_API.G_EXCEPTION_ERROR;
1105: END IF;
1106:
1107:
1108:

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

1116: x_doc_id => l_doc_id,
1117: x_doc_type => l_doc_type);
1118:
1119: --- If any errors happen abort API
1120: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1121: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1122: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1123: RAISE OKC_API.G_EXCEPTION_ERROR;
1124: END IF;

Line 1121: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1117: x_doc_type => l_doc_type);
1118:
1119: --- If any errors happen abort API
1120: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1121: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1122: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1123: RAISE OKC_API.G_EXCEPTION_ERROR;
1124: END IF;
1125:

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

1118:
1119: --- If any errors happen abort API
1120: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1121: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1122: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1123: RAISE OKC_API.G_EXCEPTION_ERROR;
1124: END IF;
1125:
1126: OKC_TERMS_VERSION_GRP.Version_doc(

Line 1123: RAISE OKC_API.G_EXCEPTION_ERROR;

1119: --- If any errors happen abort API
1120: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1121: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1122: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1123: RAISE OKC_API.G_EXCEPTION_ERROR;
1124: END IF;
1125:
1126: OKC_TERMS_VERSION_GRP.Version_doc(
1127: p_api_version => 1,

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

1133: p_version_number =>l_major_version,
1134: p_clear_amendment =>'Y');
1135:
1136: --- If any errors happen abort API
1137: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1138: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1139: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1140: RAISE OKC_API.G_EXCEPTION_ERROR;
1141: END IF;

Line 1138: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1134: p_clear_amendment =>'Y');
1135:
1136: --- If any errors happen abort API
1137: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1138: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1139: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1140: RAISE OKC_API.G_EXCEPTION_ERROR;
1141: END IF;
1142:

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

1135:
1136: --- If any errors happen abort API
1137: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1138: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1139: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1140: RAISE OKC_API.G_EXCEPTION_ERROR;
1141: END IF;
1142:
1143: -- just to save maj/min versions somewhere

Line 1140: RAISE OKC_API.G_EXCEPTION_ERROR;

1136: --- If any errors happen abort API
1137: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1138: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1139: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1140: RAISE OKC_API.G_EXCEPTION_ERROR;
1141: END IF;
1142:
1143: -- just to save maj/min versions somewhere
1144: insert into okc_k_vers_numbers_h

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

1166: where chr_id = p_chr_id;
1167:
1168: END IF;
1169:
1170: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1171: x_return_status:=l_return_status;
1172:
1173: if (p_commit = OKC_API.G_TRUE) then commit; end if;
1174:

Line 1173: if (p_commit = OKC_API.G_TRUE) then commit; end if;

1169:
1170: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1171: x_return_status:=l_return_status;
1172:
1173: if (p_commit = OKC_API.G_TRUE) then commit; end if;
1174:
1175: EXCEPTION
1176:
1177: WHEN OKC_API.G_EXCEPTION_ERROR THEN

Line 1177: WHEN OKC_API.G_EXCEPTION_ERROR THEN

1173: if (p_commit = OKC_API.G_TRUE) then commit; end if;
1174:
1175: EXCEPTION
1176:
1177: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1178: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1179: (
1180: l_api_name,
1181: G_PKG_NAME,

Line 1178: x_return_status := OKC_API.HANDLE_EXCEPTIONS

1174:
1175: EXCEPTION
1176:
1177: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1178: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1179: (
1180: l_api_name,
1181: G_PKG_NAME,
1182: 'OKC_API.G_RET_STS_ERROR',

Line 1182: 'OKC_API.G_RET_STS_ERROR',

1178: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1179: (
1180: l_api_name,
1181: G_PKG_NAME,
1182: 'OKC_API.G_RET_STS_ERROR',
1183: x_msg_count,
1184: x_msg_data,
1185: '_PVT'
1186: );

Line 1187: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

1183: x_msg_count,
1184: x_msg_data,
1185: '_PVT'
1186: );
1187: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1188: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1189: (
1190: l_api_name,
1191: G_PKG_NAME,

Line 1188: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

1184: x_msg_data,
1185: '_PVT'
1186: );
1187: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1188: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1189: (
1190: l_api_name,
1191: G_PKG_NAME,
1192: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 1192: 'OKC_API.G_RET_STS_UNEXP_ERROR',

1188: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1189: (
1190: l_api_name,
1191: G_PKG_NAME,
1192: 'OKC_API.G_RET_STS_UNEXP_ERROR',
1193: x_msg_count,
1194: x_msg_data,
1195: '_PVT'
1196: );

Line 1198: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

1194: x_msg_data,
1195: '_PVT'
1196: );
1197: WHEN OTHERS THEN
1198: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1199: (
1200: l_api_name,
1201: G_PKG_NAME,
1202: 'OTHERS',

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

1581: x_doc_id => l_doc_id,
1582: x_doc_type => l_doc_type);
1583:
1584: --- If any errors happen abort API
1585: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1586: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1587: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1588: RAISE OKC_API.G_EXCEPTION_ERROR;
1589: END IF;

Line 1586: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1582: x_doc_type => l_doc_type);
1583:
1584: --- If any errors happen abort API
1585: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1586: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1587: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1588: RAISE OKC_API.G_EXCEPTION_ERROR;
1589: END IF;
1590:

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

1583:
1584: --- If any errors happen abort API
1585: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1586: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1587: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1588: RAISE OKC_API.G_EXCEPTION_ERROR;
1589: END IF;
1590:
1591: IF p_called_from = 'ERASE_SAVED_VERSION' then

Line 1588: RAISE OKC_API.G_EXCEPTION_ERROR;

1584: --- If any errors happen abort API
1585: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1586: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1587: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1588: RAISE OKC_API.G_EXCEPTION_ERROR;
1589: END IF;
1590:
1591: IF p_called_from = 'ERASE_SAVED_VERSION' then
1592:

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

1599: p_doc_id => l_doc_id,
1600: p_version_number =>-1);
1601:
1602: --- If any errors happen abort API
1603: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1604: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1605: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1606: RAISE OKC_API.G_EXCEPTION_ERROR;
1607: END IF;

Line 1604: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1600: p_version_number =>-1);
1601:
1602: --- If any errors happen abort API
1603: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1604: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1605: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1606: RAISE OKC_API.G_EXCEPTION_ERROR;
1607: END IF;
1608: END IF;

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

1601:
1602: --- If any errors happen abort API
1603: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1604: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1605: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1606: RAISE OKC_API.G_EXCEPTION_ERROR;
1607: END IF;
1608: END IF;
1609:

Line 1606: RAISE OKC_API.G_EXCEPTION_ERROR;

1602: --- If any errors happen abort API
1603: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1604: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1605: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1606: RAISE OKC_API.G_EXCEPTION_ERROR;
1607: END IF;
1608: END IF;
1609:
1610: IF p_called_from = 'RESTORE_VERSION' then

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

1620: p_doc_id => l_doc_id,
1621: p_version_number=> cr.major_version);
1622:
1623: --- If any errors happen abort API
1624: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1625: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1626: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1627: RAISE OKC_API.G_EXCEPTION_ERROR;
1628: END IF;

Line 1625: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1621: p_version_number=> cr.major_version);
1622:
1623: --- If any errors happen abort API
1624: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1625: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1626: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1627: RAISE OKC_API.G_EXCEPTION_ERROR;
1628: END IF;
1629: END LOOP;

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

1622:
1623: --- If any errors happen abort API
1624: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1625: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1626: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1627: RAISE OKC_API.G_EXCEPTION_ERROR;
1628: END IF;
1629: END LOOP;
1630: END IF;

Line 1627: RAISE OKC_API.G_EXCEPTION_ERROR;

1623: --- If any errors happen abort API
1624: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1625: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1626: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1627: RAISE OKC_API.G_EXCEPTION_ERROR;
1628: END IF;
1629: END LOOP;
1630: END IF;
1631: --

Line 1650: p_init_msg_list IN VARCHAR2 DEFAULT OKC_API.G_FALSE,

1646: --Public procedure just to erase saved contract version
1647: PROCEDURE erase_saved_version(
1648: p_chr_id IN NUMBER,
1649: p_api_version IN NUMBER,
1650: p_init_msg_list IN VARCHAR2 DEFAULT OKC_API.G_FALSE,
1651: x_return_status OUT NOCOPY VARCHAR2,
1652: x_msg_count OUT NOCOPY NUMBER,
1653: x_msg_data OUT NOCOPY VARCHAR2,
1654: p_commit IN VARCHAR2 DEFAULT OKC_API.G_TRUE) IS

Line 1654: p_commit IN VARCHAR2 DEFAULT OKC_API.G_TRUE) IS

1650: p_init_msg_list IN VARCHAR2 DEFAULT OKC_API.G_FALSE,
1651: x_return_status OUT NOCOPY VARCHAR2,
1652: x_msg_count OUT NOCOPY NUMBER,
1653: x_msg_data OUT NOCOPY VARCHAR2,
1654: p_commit IN VARCHAR2 DEFAULT OKC_API.G_TRUE) IS
1655:
1656:
1657: l_api_version CONSTANT NUMBER := 1;
1658: l_api_name CONSTANT VARCHAR2(30) := 'V_erase_saved_version';

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

1655:
1656:
1657: l_api_version CONSTANT NUMBER := 1;
1658: l_api_name CONSTANT VARCHAR2(30) := 'V_erase_saved_version';
1659: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1660:
1661: l_cls_code OKC_SUBCLASSES_B.CLS_CODE%TYPE:=OKC_API.G_MISS_CHAR;
1662: l_pdf_id NUMBER := NULL;
1663: l_string VARCHAR2(32000);

Line 1661: l_cls_code OKC_SUBCLASSES_B.CLS_CODE%TYPE:=OKC_API.G_MISS_CHAR;

1657: l_api_version CONSTANT NUMBER := 1;
1658: l_api_name CONSTANT VARCHAR2(30) := 'V_erase_saved_version';
1659: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1660:
1661: l_cls_code OKC_SUBCLASSES_B.CLS_CODE%TYPE:=OKC_API.G_MISS_CHAR;
1662: l_pdf_id NUMBER := NULL;
1663: l_string VARCHAR2(32000);
1664: proc_string VARCHAR2(32000);
1665:

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

1675: FROM okc_class_operations
1676: WHERE opn_code = 'ERASE_VERSION'
1677: AND cls_code = p_cls_code;
1678: BEGIN
1679: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
1680: G_PKG_NAME,
1681: p_init_msg_list,
1682: l_api_version,
1683: p_api_version,

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

1682: l_api_version,
1683: p_api_version,
1684: '_PVT',
1685: x_return_status);
1686: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1687: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1688: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1689: RAISE OKC_API.G_EXCEPTION_ERROR;
1690: END IF;

Line 1687: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1683: p_api_version,
1684: '_PVT',
1685: x_return_status);
1686: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1687: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1688: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1689: RAISE OKC_API.G_EXCEPTION_ERROR;
1690: END IF;
1691: --

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

1684: '_PVT',
1685: x_return_status);
1686: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1687: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1688: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1689: RAISE OKC_API.G_EXCEPTION_ERROR;
1690: END IF;
1691: --
1692: -- All the delete lines from here are moved into private procedure delete_version

Line 1689: RAISE OKC_API.G_EXCEPTION_ERROR;

1685: x_return_status);
1686: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1687: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1688: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1689: RAISE OKC_API.G_EXCEPTION_ERROR;
1690: END IF;
1691: --
1692: -- All the delete lines from here are moved into private procedure delete_version
1693: --

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

1712: IF l_string is NOT NULL THEN
1713: proc_string := 'begin '||l_string || ' (:b1,:b2); end ;';
1714: EXECUTE IMMEDIATE proc_string using p_chr_id, out l_return_status;
1715:
1716: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1717: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1718: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1719: RAISE OKC_API.G_EXCEPTION_ERROR;
1720: END IF;

Line 1717: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1713: proc_string := 'begin '||l_string || ' (:b1,:b2); end ;';
1714: EXECUTE IMMEDIATE proc_string using p_chr_id, out l_return_status;
1715:
1716: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1717: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1718: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1719: RAISE OKC_API.G_EXCEPTION_ERROR;
1720: END IF;
1721: End If;

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

1714: EXECUTE IMMEDIATE proc_string using p_chr_id, out l_return_status;
1715:
1716: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1717: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1718: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1719: RAISE OKC_API.G_EXCEPTION_ERROR;
1720: END IF;
1721: End If;
1722:

Line 1719: RAISE OKC_API.G_EXCEPTION_ERROR;

1715:
1716: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1717: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1718: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1719: RAISE OKC_API.G_EXCEPTION_ERROR;
1720: END IF;
1721: End If;
1722:
1723: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

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

1719: RAISE OKC_API.G_EXCEPTION_ERROR;
1720: END IF;
1721: End If;
1722:
1723: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1724: x_return_status:=l_return_status;
1725:
1726: if (p_commit = OKC_API.G_TRUE) then commit; end if;
1727:

Line 1726: if (p_commit = OKC_API.G_TRUE) then commit; end if;

1722:
1723: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1724: x_return_status:=l_return_status;
1725:
1726: if (p_commit = OKC_API.G_TRUE) then commit; end if;
1727:
1728: EXCEPTION
1729:
1730: WHEN OKC_API.G_EXCEPTION_ERROR THEN

Line 1730: WHEN OKC_API.G_EXCEPTION_ERROR THEN

1726: if (p_commit = OKC_API.G_TRUE) then commit; end if;
1727:
1728: EXCEPTION
1729:
1730: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1731: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1732: (
1733: l_api_name,
1734: G_PKG_NAME,

Line 1731: x_return_status := OKC_API.HANDLE_EXCEPTIONS

1727:
1728: EXCEPTION
1729:
1730: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1731: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1732: (
1733: l_api_name,
1734: G_PKG_NAME,
1735: 'OKC_API.G_RET_STS_ERROR',

Line 1735: 'OKC_API.G_RET_STS_ERROR',

1731: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1732: (
1733: l_api_name,
1734: G_PKG_NAME,
1735: 'OKC_API.G_RET_STS_ERROR',
1736: x_msg_count,
1737: x_msg_data,
1738: '_PVT'
1739: );

Line 1740: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

1736: x_msg_count,
1737: x_msg_data,
1738: '_PVT'
1739: );
1740: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1741: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1742: (
1743: l_api_name,
1744: G_PKG_NAME,

Line 1741: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

1737: x_msg_data,
1738: '_PVT'
1739: );
1740: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1741: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1742: (
1743: l_api_name,
1744: G_PKG_NAME,
1745: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 1745: 'OKC_API.G_RET_STS_UNEXP_ERROR',

1741: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1742: (
1743: l_api_name,
1744: G_PKG_NAME,
1745: 'OKC_API.G_RET_STS_UNEXP_ERROR',
1746: x_msg_count,
1747: x_msg_data,
1748: '_PVT'
1749: );

Line 1751: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

1747: x_msg_data,
1748: '_PVT'
1749: );
1750: WHEN OTHERS THEN
1751: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1752: (
1753: l_api_name,
1754: G_PKG_NAME,
1755: 'OTHERS',

Line 1769: p_init_msg_list IN VARCHAR2 DEFAULT OKC_API.G_FALSE,

1765: --
1766: PROCEDURE restore_version(
1767: p_chr_id IN NUMBER,
1768: p_api_version IN NUMBER,
1769: p_init_msg_list IN VARCHAR2 DEFAULT OKC_API.G_FALSE,
1770: x_return_status OUT NOCOPY VARCHAR2,
1771: x_msg_count OUT NOCOPY NUMBER,
1772: x_msg_data OUT NOCOPY VARCHAR2,
1773: p_commit IN VARCHAR2 DEFAULT OKC_API.G_TRUE) IS

Line 1773: p_commit IN VARCHAR2 DEFAULT OKC_API.G_TRUE) IS

1769: p_init_msg_list IN VARCHAR2 DEFAULT OKC_API.G_FALSE,
1770: x_return_status OUT NOCOPY VARCHAR2,
1771: x_msg_count OUT NOCOPY NUMBER,
1772: x_msg_data OUT NOCOPY VARCHAR2,
1773: p_commit IN VARCHAR2 DEFAULT OKC_API.G_TRUE) IS
1774: --
1775: --
1776: l_api_version CONSTANT NUMBER := 1;
1777: l_api_name CONSTANT VARCHAR2(30) := 'V_restore_version';

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

1774: --
1775: --
1776: l_api_version CONSTANT NUMBER := 1;
1777: l_api_name CONSTANT VARCHAR2(30) := 'V_restore_version';
1778: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1779: l_major_version number;
1780: l_minor_version number;
1781: l_minus_version number := -1;
1782: l_chr_id number := p_chr_id;

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

1814: x_hstv_rec OKC_K_HISTORY_PVT.hstv_rec_type;
1815:
1816:
1817: BEGIN
1818: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
1819: G_PKG_NAME,
1820: p_init_msg_list,
1821: l_api_version,
1822: p_api_version,

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

1821: l_api_version,
1822: p_api_version,
1823: '_PVT',
1824: x_return_status);
1825: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1826: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1827: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1828: RAISE OKC_API.G_EXCEPTION_ERROR;
1829: END IF;

Line 1826: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1822: p_api_version,
1823: '_PVT',
1824: x_return_status);
1825: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1826: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1827: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1828: RAISE OKC_API.G_EXCEPTION_ERROR;
1829: END IF;
1830: --

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

1823: '_PVT',
1824: x_return_status);
1825: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1826: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1827: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1828: RAISE OKC_API.G_EXCEPTION_ERROR;
1829: END IF;
1830: --
1831: open v;

Line 1828: RAISE OKC_API.G_EXCEPTION_ERROR;

1824: x_return_status);
1825: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1826: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1827: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1828: RAISE OKC_API.G_EXCEPTION_ERROR;
1829: END IF;
1830: --
1831: open v;
1832: fetch v into l_major_version, l_minor_version;

Line 1842: OKC_API.set_message(OKC_API.G_FND_APP,OKC_API.G_FORM_UNABLE_TO_RESERVE_REC);

1838: fetch v_lock into l_dummy;
1839: close v_lock;
1840: exception
1841: when others then
1842: OKC_API.set_message(OKC_API.G_FND_APP,OKC_API.G_FORM_UNABLE_TO_RESERVE_REC);
1843: RAISE OKC_API.G_EXCEPTION_ERROR;
1844: end;
1845:
1846: -- Version Attachments - RESTORE_VERSION

Line 1843: RAISE OKC_API.G_EXCEPTION_ERROR;

1839: close v_lock;
1840: exception
1841: when others then
1842: OKC_API.set_message(OKC_API.G_FND_APP,OKC_API.G_FORM_UNABLE_TO_RESERVE_REC);
1843: RAISE OKC_API.G_EXCEPTION_ERROR;
1844: end;
1845:
1846: -- Version Attachments - RESTORE_VERSION
1847: --

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

1852: x_return_status =>l_return_status,
1853: x_msg_count =>x_msg_count,
1854: x_msg_data =>x_msg_data);
1855: --
1856: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1857: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1858: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1859: RAISE OKC_API.G_EXCEPTION_ERROR;
1860: END IF;

Line 1857: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1853: x_msg_count =>x_msg_count,
1854: x_msg_data =>x_msg_data);
1855: --
1856: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1857: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1858: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1859: RAISE OKC_API.G_EXCEPTION_ERROR;
1860: END IF;
1861: --

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

1854: x_msg_data =>x_msg_data);
1855: --
1856: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1857: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1858: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1859: RAISE OKC_API.G_EXCEPTION_ERROR;
1860: END IF;
1861: --
1862: -- To get the old status

Line 1859: RAISE OKC_API.G_EXCEPTION_ERROR;

1855: --
1856: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1857: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1858: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1859: RAISE OKC_API.G_EXCEPTION_ERROR;
1860: END IF;
1861: --
1862: -- To get the old status
1863: open l_status_csr;

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

1977: --Restore contract header
1978:
1979: l_return_status:=OKC_CHR_PVT.Restore_Version(l_chr_id,l_minus_version);
1980: --- If any errors happen abort API
1981: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1982: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1983: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1984: RAISE OKC_API.G_EXCEPTION_ERROR;
1985: END IF;

Line 1982: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1978:
1979: l_return_status:=OKC_CHR_PVT.Restore_Version(l_chr_id,l_minus_version);
1980: --- If any errors happen abort API
1981: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1982: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1983: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1984: RAISE OKC_API.G_EXCEPTION_ERROR;
1985: END IF;
1986:

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

1979: l_return_status:=OKC_CHR_PVT.Restore_Version(l_chr_id,l_minus_version);
1980: --- If any errors happen abort API
1981: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1982: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1983: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1984: RAISE OKC_API.G_EXCEPTION_ERROR;
1985: END IF;
1986:
1987: --Restore contract lines

Line 1984: RAISE OKC_API.G_EXCEPTION_ERROR;

1980: --- If any errors happen abort API
1981: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1982: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1983: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1984: RAISE OKC_API.G_EXCEPTION_ERROR;
1985: END IF;
1986:
1987: --Restore contract lines
1988:

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

1987: --Restore contract lines
1988:
1989: l_return_status:=OKC_CLE_PVT.Restore_Version(l_chr_id,l_minus_version);
1990: --- If any errors happen abort API
1991: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1992: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1993: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1994: RAISE OKC_API.G_EXCEPTION_ERROR;
1995: END IF;

Line 1992: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1988:
1989: l_return_status:=OKC_CLE_PVT.Restore_Version(l_chr_id,l_minus_version);
1990: --- If any errors happen abort API
1991: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1992: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1993: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1994: RAISE OKC_API.G_EXCEPTION_ERROR;
1995: END IF;
1996:

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

1989: l_return_status:=OKC_CLE_PVT.Restore_Version(l_chr_id,l_minus_version);
1990: --- If any errors happen abort API
1991: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1992: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1993: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1994: RAISE OKC_API.G_EXCEPTION_ERROR;
1995: END IF;
1996:
1997: --Restore contract items

Line 1994: RAISE OKC_API.G_EXCEPTION_ERROR;

1990: --- If any errors happen abort API
1991: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1992: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1993: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1994: RAISE OKC_API.G_EXCEPTION_ERROR;
1995: END IF;
1996:
1997: --Restore contract items
1998: l_return_status:=OKC_CIM_PVT.Restore_Version(l_chr_id,l_minus_version);

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

1996:
1997: --Restore contract items
1998: l_return_status:=OKC_CIM_PVT.Restore_Version(l_chr_id,l_minus_version);
1999: --- If any errors happen abort API
2000: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2001: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2002: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2003: RAISE OKC_API.G_EXCEPTION_ERROR;
2004: END IF;

Line 2001: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1997: --Restore contract items
1998: l_return_status:=OKC_CIM_PVT.Restore_Version(l_chr_id,l_minus_version);
1999: --- If any errors happen abort API
2000: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2001: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2002: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2003: RAISE OKC_API.G_EXCEPTION_ERROR;
2004: END IF;
2005:

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

1998: l_return_status:=OKC_CIM_PVT.Restore_Version(l_chr_id,l_minus_version);
1999: --- If any errors happen abort API
2000: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2001: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2002: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2003: RAISE OKC_API.G_EXCEPTION_ERROR;
2004: END IF;
2005:
2006: --Restore contract party roles

Line 2003: RAISE OKC_API.G_EXCEPTION_ERROR;

1999: --- If any errors happen abort API
2000: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2001: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2002: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2003: RAISE OKC_API.G_EXCEPTION_ERROR;
2004: END IF;
2005:
2006: --Restore contract party roles
2007: l_return_status:=OKC_CPL_PVT.Restore_Version(l_chr_id,l_minus_version);

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

2005:
2006: --Restore contract party roles
2007: l_return_status:=OKC_CPL_PVT.Restore_Version(l_chr_id,l_minus_version);
2008: --- If any errors happen abort API
2009: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2010: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2011: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2012: RAISE OKC_API.G_EXCEPTION_ERROR;
2013: END IF;

Line 2010: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2006: --Restore contract party roles
2007: l_return_status:=OKC_CPL_PVT.Restore_Version(l_chr_id,l_minus_version);
2008: --- If any errors happen abort API
2009: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2010: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2011: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2012: RAISE OKC_API.G_EXCEPTION_ERROR;
2013: END IF;
2014:

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

2007: l_return_status:=OKC_CPL_PVT.Restore_Version(l_chr_id,l_minus_version);
2008: --- If any errors happen abort API
2009: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2010: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2011: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2012: RAISE OKC_API.G_EXCEPTION_ERROR;
2013: END IF;
2014:
2015: --Restore RuleGroup party roles

Line 2012: RAISE OKC_API.G_EXCEPTION_ERROR;

2008: --- If any errors happen abort API
2009: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2010: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2011: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2012: RAISE OKC_API.G_EXCEPTION_ERROR;
2013: END IF;
2014:
2015: --Restore RuleGroup party roles
2016: l_return_status:=OKC_RMP_PVT.Restore_Version(l_chr_id,l_minus_version);

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

2014:
2015: --Restore RuleGroup party roles
2016: l_return_status:=OKC_RMP_PVT.Restore_Version(l_chr_id,l_minus_version);
2017: --- If any errors happen abort API
2018: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2019: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2020: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2021: RAISE OKC_API.G_EXCEPTION_ERROR;
2022: END IF;

Line 2019: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2015: --Restore RuleGroup party roles
2016: l_return_status:=OKC_RMP_PVT.Restore_Version(l_chr_id,l_minus_version);
2017: --- If any errors happen abort API
2018: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2019: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2020: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2021: RAISE OKC_API.G_EXCEPTION_ERROR;
2022: END IF;
2023:

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

2016: l_return_status:=OKC_RMP_PVT.Restore_Version(l_chr_id,l_minus_version);
2017: --- If any errors happen abort API
2018: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2019: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2020: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2021: RAISE OKC_API.G_EXCEPTION_ERROR;
2022: END IF;
2023:
2024: --Restore Rule Groups

Line 2021: RAISE OKC_API.G_EXCEPTION_ERROR;

2017: --- If any errors happen abort API
2018: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2019: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2020: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2021: RAISE OKC_API.G_EXCEPTION_ERROR;
2022: END IF;
2023:
2024: --Restore Rule Groups
2025: l_return_status:=OKC_RGP_PVT.Restore_Version(l_chr_id,l_minus_version);

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

2023:
2024: --Restore Rule Groups
2025: l_return_status:=OKC_RGP_PVT.Restore_Version(l_chr_id,l_minus_version);
2026: --- If any errors happen abort API
2027: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2028: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2029: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2030: RAISE OKC_API.G_EXCEPTION_ERROR;
2031: END IF;

Line 2028: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2024: --Restore Rule Groups
2025: l_return_status:=OKC_RGP_PVT.Restore_Version(l_chr_id,l_minus_version);
2026: --- If any errors happen abort API
2027: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2028: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2029: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2030: RAISE OKC_API.G_EXCEPTION_ERROR;
2031: END IF;
2032:

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

2025: l_return_status:=OKC_RGP_PVT.Restore_Version(l_chr_id,l_minus_version);
2026: --- If any errors happen abort API
2027: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2028: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2029: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2030: RAISE OKC_API.G_EXCEPTION_ERROR;
2031: END IF;
2032:
2033: --Restore Rules

Line 2030: RAISE OKC_API.G_EXCEPTION_ERROR;

2026: --- If any errors happen abort API
2027: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2028: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2029: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2030: RAISE OKC_API.G_EXCEPTION_ERROR;
2031: END IF;
2032:
2033: --Restore Rules
2034: l_return_status:=OKC_RUL_PVT.Restore_Version(l_chr_id,l_minus_version);

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

2032:
2033: --Restore Rules
2034: l_return_status:=OKC_RUL_PVT.Restore_Version(l_chr_id,l_minus_version);
2035: --- If any errors happen abort API
2036: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2037: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2038: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2039: RAISE OKC_API.G_EXCEPTION_ERROR;
2040: END IF;

Line 2037: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2033: --Restore Rules
2034: l_return_status:=OKC_RUL_PVT.Restore_Version(l_chr_id,l_minus_version);
2035: --- If any errors happen abort API
2036: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2037: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2038: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2039: RAISE OKC_API.G_EXCEPTION_ERROR;
2040: END IF;
2041:

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

2034: l_return_status:=OKC_RUL_PVT.Restore_Version(l_chr_id,l_minus_version);
2035: --- If any errors happen abort API
2036: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2037: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2038: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2039: RAISE OKC_API.G_EXCEPTION_ERROR;
2040: END IF;
2041:
2042: --Restore Contacts

Line 2039: RAISE OKC_API.G_EXCEPTION_ERROR;

2035: --- If any errors happen abort API
2036: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2037: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2038: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2039: RAISE OKC_API.G_EXCEPTION_ERROR;
2040: END IF;
2041:
2042: --Restore Contacts
2043: l_return_status:=OKC_CTC_PVT.Restore_Version(l_chr_id,l_minus_version);

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

2041:
2042: --Restore Contacts
2043: l_return_status:=OKC_CTC_PVT.Restore_Version(l_chr_id,l_minus_version);
2044: --- If any errors happen abort API
2045: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2046: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2047: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2048: RAISE OKC_API.G_EXCEPTION_ERROR;
2049: END IF;

Line 2046: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2042: --Restore Contacts
2043: l_return_status:=OKC_CTC_PVT.Restore_Version(l_chr_id,l_minus_version);
2044: --- If any errors happen abort API
2045: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2046: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2047: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2048: RAISE OKC_API.G_EXCEPTION_ERROR;
2049: END IF;
2050:

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

2043: l_return_status:=OKC_CTC_PVT.Restore_Version(l_chr_id,l_minus_version);
2044: --- If any errors happen abort API
2045: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2046: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2047: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2048: RAISE OKC_API.G_EXCEPTION_ERROR;
2049: END IF;
2050:
2051: --Restore cover times

Line 2048: RAISE OKC_API.G_EXCEPTION_ERROR;

2044: --- If any errors happen abort API
2045: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2046: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2047: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2048: RAISE OKC_API.G_EXCEPTION_ERROR;
2049: END IF;
2050:
2051: --Restore cover times
2052: l_return_status:=OKC_CTI_PVT.Restore_Version(l_chr_id,l_minus_version);

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

2050:
2051: --Restore cover times
2052: l_return_status:=OKC_CTI_PVT.Restore_Version(l_chr_id,l_minus_version);
2053: --- If any errors happen abort API
2054: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2055: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2056: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2057: RAISE OKC_API.G_EXCEPTION_ERROR;
2058: END IF;

Line 2055: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2051: --Restore cover times
2052: l_return_status:=OKC_CTI_PVT.Restore_Version(l_chr_id,l_minus_version);
2053: --- If any errors happen abort API
2054: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2055: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2056: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2057: RAISE OKC_API.G_EXCEPTION_ERROR;
2058: END IF;
2059:

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

2052: l_return_status:=OKC_CTI_PVT.Restore_Version(l_chr_id,l_minus_version);
2053: --- If any errors happen abort API
2054: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2055: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2056: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2057: RAISE OKC_API.G_EXCEPTION_ERROR;
2058: END IF;
2059:
2060: --Restore contract accesses

Line 2057: RAISE OKC_API.G_EXCEPTION_ERROR;

2053: --- If any errors happen abort API
2054: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2055: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2056: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2057: RAISE OKC_API.G_EXCEPTION_ERROR;
2058: END IF;
2059:
2060: --Restore contract accesses
2061: l_return_status:=OKC_CAC_PVT.Restore_Version(l_chr_id,l_minus_version);

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

2059:
2060: --Restore contract accesses
2061: l_return_status:=OKC_CAC_PVT.Restore_Version(l_chr_id,l_minus_version);
2062: --- If any errors happen abort API
2063: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2064: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2065: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2066: RAISE OKC_API.G_EXCEPTION_ERROR;
2067: END IF;

Line 2064: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2060: --Restore contract accesses
2061: l_return_status:=OKC_CAC_PVT.Restore_Version(l_chr_id,l_minus_version);
2062: --- If any errors happen abort API
2063: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2064: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2065: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2066: RAISE OKC_API.G_EXCEPTION_ERROR;
2067: END IF;
2068:

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

2061: l_return_status:=OKC_CAC_PVT.Restore_Version(l_chr_id,l_minus_version);
2062: --- If any errors happen abort API
2063: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2064: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2065: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2066: RAISE OKC_API.G_EXCEPTION_ERROR;
2067: END IF;
2068:
2069: --Restore outcome arguments

Line 2066: RAISE OKC_API.G_EXCEPTION_ERROR;

2062: --- If any errors happen abort API
2063: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2064: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2065: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2066: RAISE OKC_API.G_EXCEPTION_ERROR;
2067: END IF;
2068:
2069: --Restore outcome arguments
2070: l_return_status:=OKC_OAT_PVT.Restore_Version(l_chr_id,l_minus_version);

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

2068:
2069: --Restore outcome arguments
2070: l_return_status:=OKC_OAT_PVT.Restore_Version(l_chr_id,l_minus_version);
2071: --- If any errors happen abort API
2072: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2073: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2074: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2075: RAISE OKC_API.G_EXCEPTION_ERROR;
2076: END IF;

Line 2073: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2069: --Restore outcome arguments
2070: l_return_status:=OKC_OAT_PVT.Restore_Version(l_chr_id,l_minus_version);
2071: --- If any errors happen abort API
2072: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2073: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2074: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2075: RAISE OKC_API.G_EXCEPTION_ERROR;
2076: END IF;
2077:

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

2070: l_return_status:=OKC_OAT_PVT.Restore_Version(l_chr_id,l_minus_version);
2071: --- If any errors happen abort API
2072: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2073: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2074: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2075: RAISE OKC_API.G_EXCEPTION_ERROR;
2076: END IF;
2077:
2078: --Restore outcomes

Line 2075: RAISE OKC_API.G_EXCEPTION_ERROR;

2071: --- If any errors happen abort API
2072: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2073: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2074: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2075: RAISE OKC_API.G_EXCEPTION_ERROR;
2076: END IF;
2077:
2078: --Restore outcomes
2079: l_return_status:=OKC_OCE_PVT.Restore_Version(l_chr_id,l_minus_version);

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

2077:
2078: --Restore outcomes
2079: l_return_status:=OKC_OCE_PVT.Restore_Version(l_chr_id,l_minus_version);
2080: --- If any errors happen abort API
2081: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2082: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2083: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2084: RAISE OKC_API.G_EXCEPTION_ERROR;
2085: END IF;

Line 2082: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2078: --Restore outcomes
2079: l_return_status:=OKC_OCE_PVT.Restore_Version(l_chr_id,l_minus_version);
2080: --- If any errors happen abort API
2081: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2082: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2083: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2084: RAISE OKC_API.G_EXCEPTION_ERROR;
2085: END IF;
2086:

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

2079: l_return_status:=OKC_OCE_PVT.Restore_Version(l_chr_id,l_minus_version);
2080: --- If any errors happen abort API
2081: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2082: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2083: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2084: RAISE OKC_API.G_EXCEPTION_ERROR;
2085: END IF;
2086:
2087: --Restore react intervals

Line 2084: RAISE OKC_API.G_EXCEPTION_ERROR;

2080: --- If any errors happen abort API
2081: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2082: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2083: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2084: RAISE OKC_API.G_EXCEPTION_ERROR;
2085: END IF;
2086:
2087: --Restore react intervals
2088: l_return_status:=OKC_RIL_PVT.Restore_Version(l_chr_id,l_minus_version);

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

2086:
2087: --Restore react intervals
2088: l_return_status:=OKC_RIL_PVT.Restore_Version(l_chr_id,l_minus_version);
2089: --- If any errors happen abort API
2090: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2091: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2092: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2093: RAISE OKC_API.G_EXCEPTION_ERROR;
2094: END IF;

Line 2091: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2087: --Restore react intervals
2088: l_return_status:=OKC_RIL_PVT.Restore_Version(l_chr_id,l_minus_version);
2089: --- If any errors happen abort API
2090: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2091: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2092: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2093: RAISE OKC_API.G_EXCEPTION_ERROR;
2094: END IF;
2095:

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

2088: l_return_status:=OKC_RIL_PVT.Restore_Version(l_chr_id,l_minus_version);
2089: --- If any errors happen abort API
2090: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2091: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2092: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2093: RAISE OKC_API.G_EXCEPTION_ERROR;
2094: END IF;
2095:
2096:

Line 2093: RAISE OKC_API.G_EXCEPTION_ERROR;

2089: --- If any errors happen abort API
2090: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2091: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2092: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2093: RAISE OKC_API.G_EXCEPTION_ERROR;
2094: END IF;
2095:
2096:
2097: --Restore timevalues

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

2096:
2097: --Restore timevalues
2098: l_return_status:=OKC_TAV_PVT.Restore_Version(l_chr_id,l_minus_version);
2099: --- If any errors happen abort API
2100: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2101: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2102: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2103: RAISE OKC_API.G_EXCEPTION_ERROR;
2104: END IF;

Line 2101: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2097: --Restore timevalues
2098: l_return_status:=OKC_TAV_PVT.Restore_Version(l_chr_id,l_minus_version);
2099: --- If any errors happen abort API
2100: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2101: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2102: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2103: RAISE OKC_API.G_EXCEPTION_ERROR;
2104: END IF;
2105:

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

2098: l_return_status:=OKC_TAV_PVT.Restore_Version(l_chr_id,l_minus_version);
2099: --- If any errors happen abort API
2100: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2101: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2102: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2103: RAISE OKC_API.G_EXCEPTION_ERROR;
2104: END IF;
2105:
2106: --Restore contract processes

Line 2103: RAISE OKC_API.G_EXCEPTION_ERROR;

2099: --- If any errors happen abort API
2100: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2101: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2102: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2103: RAISE OKC_API.G_EXCEPTION_ERROR;
2104: END IF;
2105:
2106: --Restore contract processes
2107: l_return_status:=OKC_CPS_PVT.Restore_Version(l_chr_id,l_minus_version);

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

2105:
2106: --Restore contract processes
2107: l_return_status:=OKC_CPS_PVT.Restore_Version(l_chr_id,l_minus_version);
2108: --- If any errors happen abort API
2109: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2110: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2111: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2112: RAISE OKC_API.G_EXCEPTION_ERROR;
2113: END IF;

Line 2110: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2106: --Restore contract processes
2107: l_return_status:=OKC_CPS_PVT.Restore_Version(l_chr_id,l_minus_version);
2108: --- If any errors happen abort API
2109: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2110: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2111: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2112: RAISE OKC_API.G_EXCEPTION_ERROR;
2113: END IF;
2114:

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

2107: l_return_status:=OKC_CPS_PVT.Restore_Version(l_chr_id,l_minus_version);
2108: --- If any errors happen abort API
2109: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2110: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2111: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2112: RAISE OKC_API.G_EXCEPTION_ERROR;
2113: END IF;
2114:
2115: -- condition headers

Line 2112: RAISE OKC_API.G_EXCEPTION_ERROR;

2108: --- If any errors happen abort API
2109: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2110: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2111: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2112: RAISE OKC_API.G_EXCEPTION_ERROR;
2113: END IF;
2114:
2115: -- condition headers
2116: l_return_status:=OKC_CNH_PVT.Restore_Version(l_chr_id,l_minus_version);

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

2114:
2115: -- condition headers
2116: l_return_status:=OKC_CNH_PVT.Restore_Version(l_chr_id,l_minus_version);
2117: --- If any errors happen abort API
2118: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2119: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2120: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2121: RAISE OKC_API.G_EXCEPTION_ERROR;
2122: END IF;

Line 2119: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2115: -- condition headers
2116: l_return_status:=OKC_CNH_PVT.Restore_Version(l_chr_id,l_minus_version);
2117: --- If any errors happen abort API
2118: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2119: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2120: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2121: RAISE OKC_API.G_EXCEPTION_ERROR;
2122: END IF;
2123:

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

2116: l_return_status:=OKC_CNH_PVT.Restore_Version(l_chr_id,l_minus_version);
2117: --- If any errors happen abort API
2118: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2119: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2120: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2121: RAISE OKC_API.G_EXCEPTION_ERROR;
2122: END IF;
2123:
2124:

Line 2121: RAISE OKC_API.G_EXCEPTION_ERROR;

2117: --- If any errors happen abort API
2118: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2119: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2120: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2121: RAISE OKC_API.G_EXCEPTION_ERROR;
2122: END IF;
2123:
2124:
2125: --Restore condition lines

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

2124:
2125: --Restore condition lines
2126: l_return_status:=OKC_CNL_PVT.Restore_Version(l_chr_id,l_minus_version);
2127: --- If any errors happen abort API
2128: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2129: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2130: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2131: RAISE OKC_API.G_EXCEPTION_ERROR;
2132: END IF;

Line 2129: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2125: --Restore condition lines
2126: l_return_status:=OKC_CNL_PVT.Restore_Version(l_chr_id,l_minus_version);
2127: --- If any errors happen abort API
2128: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2129: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2130: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2131: RAISE OKC_API.G_EXCEPTION_ERROR;
2132: END IF;
2133:

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

2126: l_return_status:=OKC_CNL_PVT.Restore_Version(l_chr_id,l_minus_version);
2127: --- If any errors happen abort API
2128: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2129: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2130: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2131: RAISE OKC_API.G_EXCEPTION_ERROR;
2132: END IF;
2133:
2134: --Restore function_expr_params

Line 2131: RAISE OKC_API.G_EXCEPTION_ERROR;

2127: --- If any errors happen abort API
2128: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2129: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2130: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2131: RAISE OKC_API.G_EXCEPTION_ERROR;
2132: END IF;
2133:
2134: --Restore function_expr_params
2135: l_return_status:=OKC_FEP_PVT.Restore_Version(l_chr_id,l_minus_version);

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

2133:
2134: --Restore function_expr_params
2135: l_return_status:=OKC_FEP_PVT.Restore_Version(l_chr_id,l_minus_version);
2136: --- If any errors happen abort API
2137: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2138: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2139: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2140: RAISE OKC_API.G_EXCEPTION_ERROR;
2141: END IF;

Line 2138: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2134: --Restore function_expr_params
2135: l_return_status:=OKC_FEP_PVT.Restore_Version(l_chr_id,l_minus_version);
2136: --- If any errors happen abort API
2137: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2138: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2139: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2140: RAISE OKC_API.G_EXCEPTION_ERROR;
2141: END IF;
2142:

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

2135: l_return_status:=OKC_FEP_PVT.Restore_Version(l_chr_id,l_minus_version);
2136: --- If any errors happen abort API
2137: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2138: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2139: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2140: RAISE OKC_API.G_EXCEPTION_ERROR;
2141: END IF;
2142:
2143: --Restore governances

Line 2140: RAISE OKC_API.G_EXCEPTION_ERROR;

2136: --- If any errors happen abort API
2137: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2138: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2139: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2140: RAISE OKC_API.G_EXCEPTION_ERROR;
2141: END IF;
2142:
2143: --Restore governances
2144: l_return_status:=OKC_GVE_PVT.Restore_Version(l_chr_id,l_minus_version);

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

2142:
2143: --Restore governances
2144: l_return_status:=OKC_GVE_PVT.Restore_Version(l_chr_id,l_minus_version);
2145: --- If any errors happen abort API
2146: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2147: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2148: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2149: RAISE OKC_API.G_EXCEPTION_ERROR;
2150: END IF;

Line 2147: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2143: --Restore governances
2144: l_return_status:=OKC_GVE_PVT.Restore_Version(l_chr_id,l_minus_version);
2145: --- If any errors happen abort API
2146: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2147: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2148: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2149: RAISE OKC_API.G_EXCEPTION_ERROR;
2150: END IF;
2151:

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

2144: l_return_status:=OKC_GVE_PVT.Restore_Version(l_chr_id,l_minus_version);
2145: --- If any errors happen abort API
2146: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2147: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2148: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2149: RAISE OKC_API.G_EXCEPTION_ERROR;
2150: END IF;
2151:
2152: --Restore _OKC_PRICE_ADJUSTMENTS

Line 2149: RAISE OKC_API.G_EXCEPTION_ERROR;

2145: --- If any errors happen abort API
2146: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2147: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2148: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2149: RAISE OKC_API.G_EXCEPTION_ERROR;
2150: END IF;
2151:
2152: --Restore _OKC_PRICE_ADJUSTMENTS
2153: l_return_status:=OKC_PAT_PVT.Restore_Version(l_chr_id,l_minus_version);

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

2151:
2152: --Restore _OKC_PRICE_ADJUSTMENTS
2153: l_return_status:=OKC_PAT_PVT.Restore_Version(l_chr_id,l_minus_version);
2154: --- If any errors happen abort API
2155: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2156: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2157: ELSIF (l_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: --Restore _OKC_PRICE_ADJUSTMENTS
2153: l_return_status:=OKC_PAT_PVT.Restore_Version(l_chr_id,l_minus_version);
2154: --- If any errors happen abort API
2155: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2156: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2157: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2158: RAISE OKC_API.G_EXCEPTION_ERROR;
2159: END IF;
2160:

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

2153: l_return_status:=OKC_PAT_PVT.Restore_Version(l_chr_id,l_minus_version);
2154: --- If any errors happen abort API
2155: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2156: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2157: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2158: RAISE OKC_API.G_EXCEPTION_ERROR;
2159: END IF;
2160:
2161: --Restore _OKC_PRICE_ADJ_ASSOCS

Line 2158: RAISE OKC_API.G_EXCEPTION_ERROR;

2154: --- If any errors happen abort API
2155: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2156: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2157: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2158: RAISE OKC_API.G_EXCEPTION_ERROR;
2159: END IF;
2160:
2161: --Restore _OKC_PRICE_ADJ_ASSOCS
2162: l_return_status:=OKC_PAC_PVT.Restore_Version(l_chr_id,l_minus_version);

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

2160:
2161: --Restore _OKC_PRICE_ADJ_ASSOCS
2162: l_return_status:=OKC_PAC_PVT.Restore_Version(l_chr_id,l_minus_version);
2163: --- If any errors happen abort API
2164: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2165: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2166: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2167: RAISE OKC_API.G_EXCEPTION_ERROR;
2168: END IF;

Line 2165: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2161: --Restore _OKC_PRICE_ADJ_ASSOCS
2162: l_return_status:=OKC_PAC_PVT.Restore_Version(l_chr_id,l_minus_version);
2163: --- If any errors happen abort API
2164: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2165: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2166: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2167: RAISE OKC_API.G_EXCEPTION_ERROR;
2168: END IF;
2169:

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

2162: l_return_status:=OKC_PAC_PVT.Restore_Version(l_chr_id,l_minus_version);
2163: --- If any errors happen abort API
2164: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2165: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2166: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2167: RAISE OKC_API.G_EXCEPTION_ERROR;
2168: END IF;
2169:
2170: --Restore _OKC_PRICE_ADJ_ATTRIBS

Line 2167: RAISE OKC_API.G_EXCEPTION_ERROR;

2163: --- If any errors happen abort API
2164: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2165: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2166: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2167: RAISE OKC_API.G_EXCEPTION_ERROR;
2168: END IF;
2169:
2170: --Restore _OKC_PRICE_ADJ_ATTRIBS
2171: l_return_status:=OKC_PAA_PVT.Restore_Version(l_chr_id,l_minus_version);

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

2169:
2170: --Restore _OKC_PRICE_ADJ_ATTRIBS
2171: l_return_status:=OKC_PAA_PVT.Restore_Version(l_chr_id,l_minus_version);
2172: --- If any errors happen abort API
2173: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2174: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2175: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2176: RAISE OKC_API.G_EXCEPTION_ERROR;
2177: END IF;

Line 2174: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2170: --Restore _OKC_PRICE_ADJ_ATTRIBS
2171: l_return_status:=OKC_PAA_PVT.Restore_Version(l_chr_id,l_minus_version);
2172: --- If any errors happen abort API
2173: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2174: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2175: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2176: RAISE OKC_API.G_EXCEPTION_ERROR;
2177: END IF;
2178:

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

2171: l_return_status:=OKC_PAA_PVT.Restore_Version(l_chr_id,l_minus_version);
2172: --- If any errors happen abort API
2173: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2174: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2175: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2176: RAISE OKC_API.G_EXCEPTION_ERROR;
2177: END IF;
2178:
2179: --Restore _OKC_PRICE_ATT_VALUES

Line 2176: RAISE OKC_API.G_EXCEPTION_ERROR;

2172: --- If any errors happen abort API
2173: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2174: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2175: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2176: RAISE OKC_API.G_EXCEPTION_ERROR;
2177: END IF;
2178:
2179: --Restore _OKC_PRICE_ATT_VALUES
2180: l_return_status:=OKC_PAV_PVT.Restore_Version(l_chr_id,l_minus_version);

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

2178:
2179: --Restore _OKC_PRICE_ATT_VALUES
2180: l_return_status:=OKC_PAV_PVT.Restore_Version(l_chr_id,l_minus_version);
2181: --- If any errors happen abort API
2182: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2183: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2184: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2185: RAISE OKC_API.G_EXCEPTION_ERROR;
2186: END IF;

Line 2183: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2179: --Restore _OKC_PRICE_ATT_VALUES
2180: l_return_status:=OKC_PAV_PVT.Restore_Version(l_chr_id,l_minus_version);
2181: --- If any errors happen abort API
2182: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2183: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2184: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2185: RAISE OKC_API.G_EXCEPTION_ERROR;
2186: END IF;
2187:

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

2180: l_return_status:=OKC_PAV_PVT.Restore_Version(l_chr_id,l_minus_version);
2181: --- If any errors happen abort API
2182: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2183: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2184: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2185: RAISE OKC_API.G_EXCEPTION_ERROR;
2186: END IF;
2187:
2188:

Line 2185: RAISE OKC_API.G_EXCEPTION_ERROR;

2181: --- If any errors happen abort API
2182: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2183: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2184: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2185: RAISE OKC_API.G_EXCEPTION_ERROR;
2186: END IF;
2187:
2188:
2189: --Restore OKC_K_SALES_CREDITS

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

2188:
2189: --Restore OKC_K_SALES_CREDITS
2190: l_return_status:=OKC_SCR_PVT.Restore_Version(l_chr_id,l_minus_version);
2191: --- If any errors happen abort API
2192: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2193: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2194: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2195: RAISE OKC_API.G_EXCEPTION_ERROR;
2196: END IF;

Line 2193: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2189: --Restore OKC_K_SALES_CREDITS
2190: l_return_status:=OKC_SCR_PVT.Restore_Version(l_chr_id,l_minus_version);
2191: --- If any errors happen abort API
2192: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2193: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2194: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2195: RAISE OKC_API.G_EXCEPTION_ERROR;
2196: END IF;
2197:

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

2190: l_return_status:=OKC_SCR_PVT.Restore_Version(l_chr_id,l_minus_version);
2191: --- If any errors happen abort API
2192: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2193: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2194: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2195: RAISE OKC_API.G_EXCEPTION_ERROR;
2196: END IF;
2197:
2198: --Restore PRICE HOLD BREAK LINES

Line 2195: RAISE OKC_API.G_EXCEPTION_ERROR;

2191: --- If any errors happen abort API
2192: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2193: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2194: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2195: RAISE OKC_API.G_EXCEPTION_ERROR;
2196: END IF;
2197:
2198: --Restore PRICE HOLD BREAK LINES
2199: l_return_status:=OKC_PHL_PVT.Restore_Version(l_chr_id,l_minus_version);

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

2197:
2198: --Restore PRICE HOLD BREAK LINES
2199: l_return_status:=OKC_PHL_PVT.Restore_Version(l_chr_id,l_minus_version);
2200: --- If any errors happen abort API
2201: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2202: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2203: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2204: RAISE OKC_API.G_EXCEPTION_ERROR;
2205: END IF;

Line 2202: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2198: --Restore PRICE HOLD BREAK LINES
2199: l_return_status:=OKC_PHL_PVT.Restore_Version(l_chr_id,l_minus_version);
2200: --- If any errors happen abort API
2201: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2202: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2203: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2204: RAISE OKC_API.G_EXCEPTION_ERROR;
2205: END IF;
2206:

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

2199: l_return_status:=OKC_PHL_PVT.Restore_Version(l_chr_id,l_minus_version);
2200: --- If any errors happen abort API
2201: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2202: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2203: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2204: RAISE OKC_API.G_EXCEPTION_ERROR;
2205: END IF;
2206:
2207: okc_terms_util_grp.get_contract_document_type_id(

Line 2204: RAISE OKC_API.G_EXCEPTION_ERROR;

2200: --- If any errors happen abort API
2201: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2202: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2203: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2204: RAISE OKC_API.G_EXCEPTION_ERROR;
2205: END IF;
2206:
2207: okc_terms_util_grp.get_contract_document_type_id(
2208: p_api_version => 1,

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

2213: p_chr_id => l_chr_id,
2214: x_doc_id => l_doc_id,
2215: x_doc_type => l_doc_type);
2216: --- If any errors happen abort API
2217: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2218: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2219: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2220: RAISE OKC_API.G_EXCEPTION_ERROR;
2221: END IF;

Line 2218: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2214: x_doc_id => l_doc_id,
2215: x_doc_type => l_doc_type);
2216: --- If any errors happen abort API
2217: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2218: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2219: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2220: RAISE OKC_API.G_EXCEPTION_ERROR;
2221: END IF;
2222:

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

2215: x_doc_type => l_doc_type);
2216: --- If any errors happen abort API
2217: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2218: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2219: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2220: RAISE OKC_API.G_EXCEPTION_ERROR;
2221: END IF;
2222:
2223: OKC_TERMS_VERSION_GRP.restore_doc_version(

Line 2220: RAISE OKC_API.G_EXCEPTION_ERROR;

2216: --- If any errors happen abort API
2217: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2218: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2219: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2220: RAISE OKC_API.G_EXCEPTION_ERROR;
2221: END IF;
2222:
2223: OKC_TERMS_VERSION_GRP.restore_doc_version(
2224: p_api_version => 1,

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

2229: p_doc_id => l_doc_id,
2230: p_version_number =>l_major_version);
2231:
2232: --- If any errors happen abort API
2233: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2234: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2235: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2236: RAISE OKC_API.G_EXCEPTION_ERROR;
2237: END IF;

Line 2234: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2230: p_version_number =>l_major_version);
2231:
2232: --- If any errors happen abort API
2233: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2234: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2235: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2236: RAISE OKC_API.G_EXCEPTION_ERROR;
2237: END IF;
2238:

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

2231:
2232: --- If any errors happen abort API
2233: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2234: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2235: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2236: RAISE OKC_API.G_EXCEPTION_ERROR;
2237: END IF;
2238:
2239: oks_contract_hdr_pub.restore_version

Line 2236: RAISE OKC_API.G_EXCEPTION_ERROR;

2232: --- If any errors happen abort API
2233: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2234: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2235: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2236: RAISE OKC_API.G_EXCEPTION_ERROR;
2237: END IF;
2238:
2239: oks_contract_hdr_pub.restore_version
2240: ( 1 ,

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

2243: l_msg_count ,
2244: l_msg_data ,
2245: l_chr_id );
2246: --- If any errors happen abort API
2247: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2248: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2249: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2250: RAISE OKC_API.G_EXCEPTION_ERROR;
2251: END IF;

Line 2248: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2244: l_msg_data ,
2245: l_chr_id );
2246: --- If any errors happen abort API
2247: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2248: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2249: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2250: RAISE OKC_API.G_EXCEPTION_ERROR;
2251: END IF;
2252:

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

2245: l_chr_id );
2246: --- If any errors happen abort API
2247: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2248: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2249: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2250: RAISE OKC_API.G_EXCEPTION_ERROR;
2251: END IF;
2252:
2253:

Line 2250: RAISE OKC_API.G_EXCEPTION_ERROR;

2246: --- If any errors happen abort API
2247: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2248: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2249: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2250: RAISE OKC_API.G_EXCEPTION_ERROR;
2251: END IF;
2252:
2253:
2254: delete from okc_k_vers_numbers where CHR_ID = p_chr_id;

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

2315:
2316:
2317:
2318:
2319: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
2320: x_return_status:=l_return_status;
2321:
2322: if (p_commit = OKC_API.G_TRUE) then commit; end if;
2323:

Line 2322: if (p_commit = OKC_API.G_TRUE) then commit; end if;

2318:
2319: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
2320: x_return_status:=l_return_status;
2321:
2322: if (p_commit = OKC_API.G_TRUE) then commit; end if;
2323:
2324: EXCEPTION
2325:
2326: WHEN OKC_API.G_EXCEPTION_ERROR THEN

Line 2326: WHEN OKC_API.G_EXCEPTION_ERROR THEN

2322: if (p_commit = OKC_API.G_TRUE) then commit; end if;
2323:
2324: EXCEPTION
2325:
2326: WHEN OKC_API.G_EXCEPTION_ERROR THEN
2327: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2328: (
2329: l_api_name,
2330: G_PKG_NAME,

Line 2327: x_return_status := OKC_API.HANDLE_EXCEPTIONS

2323:
2324: EXCEPTION
2325:
2326: WHEN OKC_API.G_EXCEPTION_ERROR THEN
2327: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2328: (
2329: l_api_name,
2330: G_PKG_NAME,
2331: 'OKC_API.G_RET_STS_ERROR',

Line 2331: 'OKC_API.G_RET_STS_ERROR',

2327: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2328: (
2329: l_api_name,
2330: G_PKG_NAME,
2331: 'OKC_API.G_RET_STS_ERROR',
2332: x_msg_count,
2333: x_msg_data,
2334: '_PVT'
2335: );

Line 2336: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

2332: x_msg_count,
2333: x_msg_data,
2334: '_PVT'
2335: );
2336: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
2337: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
2338: (
2339: l_api_name,
2340: G_PKG_NAME,

Line 2337: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

2333: x_msg_data,
2334: '_PVT'
2335: );
2336: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
2337: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
2338: (
2339: l_api_name,
2340: G_PKG_NAME,
2341: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 2341: 'OKC_API.G_RET_STS_UNEXP_ERROR',

2337: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
2338: (
2339: l_api_name,
2340: G_PKG_NAME,
2341: 'OKC_API.G_RET_STS_UNEXP_ERROR',
2342: x_msg_count,
2343: x_msg_data,
2344: '_PVT'
2345: );

Line 2347: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

2343: x_msg_data,
2344: '_PVT'
2345: );
2346: WHEN OTHERS THEN
2347: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
2348: (
2349: l_api_name,
2350: G_PKG_NAME,
2351: 'OTHERS',