DBA Data[Home] [Help]

APPS.OKC_CONTRACT_PVT dependencies on OKC_API

Line 11: G_APP_NAME CONSTANT VARCHAR2(3) := OKC_API.G_APP_NAME;

7:
8: ---------------------------------------------------------------------------
9: -- GLOBAL VARIABLES
10: ---------------------------------------------------------------------------
11: G_APP_NAME CONSTANT VARCHAR2(3) := OKC_API.G_APP_NAME;
12: G_NO_PARENT_RECORD CONSTANT VARCHAR2(200) := 'OKC_NO_PARENT_RECORD';
13: G_UNEXPECTED_ERROR CONSTANT VARCHAR2(200) := 'OKC_CONTRACTS_UNEXPECTED_ERROR';
14: G_PARENT_TABLE_TOKEN CONSTANT VARCHAR2(200) := OKC_API.G_PARENT_TABLE_TOKEN;
15: G_CHILD_TABLE_TOKEN CONSTANT VARCHAR2(200) := OKC_API.G_CHILD_TABLE_TOKEN;

Line 14: G_PARENT_TABLE_TOKEN CONSTANT VARCHAR2(200) := OKC_API.G_PARENT_TABLE_TOKEN;

10: ---------------------------------------------------------------------------
11: G_APP_NAME CONSTANT VARCHAR2(3) := OKC_API.G_APP_NAME;
12: G_NO_PARENT_RECORD CONSTANT VARCHAR2(200) := 'OKC_NO_PARENT_RECORD';
13: G_UNEXPECTED_ERROR CONSTANT VARCHAR2(200) := 'OKC_CONTRACTS_UNEXPECTED_ERROR';
14: G_PARENT_TABLE_TOKEN CONSTANT VARCHAR2(200) := OKC_API.G_PARENT_TABLE_TOKEN;
15: G_CHILD_TABLE_TOKEN CONSTANT VARCHAR2(200) := OKC_API.G_CHILD_TABLE_TOKEN;
16: G_SQLERRM_TOKEN CONSTANT VARCHAR2(200) := 'SQLerrm';
17: G_SQLCODE_TOKEN CONSTANT VARCHAR2(200) := 'SQLcode';
18: G_REQUIRED_VALUE CONSTANT VARCHAR2(200) := OKC_API.G_REQUIRED_VALUE;

Line 15: G_CHILD_TABLE_TOKEN CONSTANT VARCHAR2(200) := OKC_API.G_CHILD_TABLE_TOKEN;

11: G_APP_NAME CONSTANT VARCHAR2(3) := OKC_API.G_APP_NAME;
12: G_NO_PARENT_RECORD CONSTANT VARCHAR2(200) := 'OKC_NO_PARENT_RECORD';
13: G_UNEXPECTED_ERROR CONSTANT VARCHAR2(200) := 'OKC_CONTRACTS_UNEXPECTED_ERROR';
14: G_PARENT_TABLE_TOKEN CONSTANT VARCHAR2(200) := OKC_API.G_PARENT_TABLE_TOKEN;
15: G_CHILD_TABLE_TOKEN CONSTANT VARCHAR2(200) := OKC_API.G_CHILD_TABLE_TOKEN;
16: G_SQLERRM_TOKEN CONSTANT VARCHAR2(200) := 'SQLerrm';
17: G_SQLCODE_TOKEN CONSTANT VARCHAR2(200) := 'SQLcode';
18: G_REQUIRED_VALUE CONSTANT VARCHAR2(200) := OKC_API.G_REQUIRED_VALUE;
19: G_INVALID_VALUE CONSTANT VARCHAR2(200) := OKC_API.G_INVALID_VALUE;

Line 18: G_REQUIRED_VALUE CONSTANT VARCHAR2(200) := OKC_API.G_REQUIRED_VALUE;

14: G_PARENT_TABLE_TOKEN CONSTANT VARCHAR2(200) := OKC_API.G_PARENT_TABLE_TOKEN;
15: G_CHILD_TABLE_TOKEN CONSTANT VARCHAR2(200) := OKC_API.G_CHILD_TABLE_TOKEN;
16: G_SQLERRM_TOKEN CONSTANT VARCHAR2(200) := 'SQLerrm';
17: G_SQLCODE_TOKEN CONSTANT VARCHAR2(200) := 'SQLcode';
18: G_REQUIRED_VALUE CONSTANT VARCHAR2(200) := OKC_API.G_REQUIRED_VALUE;
19: G_INVALID_VALUE CONSTANT VARCHAR2(200) := OKC_API.G_INVALID_VALUE;
20: G_COL_NAME_TOKEN CONSTANT VARCHAR2(200) := OKC_API.G_COL_NAME_TOKEN;
21: G_TABLE_TOKEN CONSTANT VARCHAR2(200) := OKC_API.G_CHILD_TABLE_TOKEN;
22: G_EXCEPTION_HALT_VALIDATION exception;

Line 19: G_INVALID_VALUE CONSTANT VARCHAR2(200) := OKC_API.G_INVALID_VALUE;

15: G_CHILD_TABLE_TOKEN CONSTANT VARCHAR2(200) := OKC_API.G_CHILD_TABLE_TOKEN;
16: G_SQLERRM_TOKEN CONSTANT VARCHAR2(200) := 'SQLerrm';
17: G_SQLCODE_TOKEN CONSTANT VARCHAR2(200) := 'SQLcode';
18: G_REQUIRED_VALUE CONSTANT VARCHAR2(200) := OKC_API.G_REQUIRED_VALUE;
19: G_INVALID_VALUE CONSTANT VARCHAR2(200) := OKC_API.G_INVALID_VALUE;
20: G_COL_NAME_TOKEN CONSTANT VARCHAR2(200) := OKC_API.G_COL_NAME_TOKEN;
21: G_TABLE_TOKEN CONSTANT VARCHAR2(200) := OKC_API.G_CHILD_TABLE_TOKEN;
22: G_EXCEPTION_HALT_VALIDATION exception;
23: NO_CONTRACT_FOUND exception;

Line 20: G_COL_NAME_TOKEN CONSTANT VARCHAR2(200) := OKC_API.G_COL_NAME_TOKEN;

16: G_SQLERRM_TOKEN CONSTANT VARCHAR2(200) := 'SQLerrm';
17: G_SQLCODE_TOKEN CONSTANT VARCHAR2(200) := 'SQLcode';
18: G_REQUIRED_VALUE CONSTANT VARCHAR2(200) := OKC_API.G_REQUIRED_VALUE;
19: G_INVALID_VALUE CONSTANT VARCHAR2(200) := OKC_API.G_INVALID_VALUE;
20: G_COL_NAME_TOKEN CONSTANT VARCHAR2(200) := OKC_API.G_COL_NAME_TOKEN;
21: G_TABLE_TOKEN CONSTANT VARCHAR2(200) := OKC_API.G_CHILD_TABLE_TOKEN;
22: G_EXCEPTION_HALT_VALIDATION exception;
23: NO_CONTRACT_FOUND exception;
24: G_NO_UPDATE_ALLOWED_EXCEPTION exception;

Line 21: G_TABLE_TOKEN CONSTANT VARCHAR2(200) := OKC_API.G_CHILD_TABLE_TOKEN;

17: G_SQLCODE_TOKEN CONSTANT VARCHAR2(200) := 'SQLcode';
18: G_REQUIRED_VALUE CONSTANT VARCHAR2(200) := OKC_API.G_REQUIRED_VALUE;
19: G_INVALID_VALUE CONSTANT VARCHAR2(200) := OKC_API.G_INVALID_VALUE;
20: G_COL_NAME_TOKEN CONSTANT VARCHAR2(200) := OKC_API.G_COL_NAME_TOKEN;
21: G_TABLE_TOKEN CONSTANT VARCHAR2(200) := OKC_API.G_CHILD_TABLE_TOKEN;
22: G_EXCEPTION_HALT_VALIDATION exception;
23: NO_CONTRACT_FOUND exception;
24: G_NO_UPDATE_ALLOWED_EXCEPTION exception;
25: G_NO_UPDATE_ALLOWED CONSTANT VARCHAR2(200) := 'OKC_NO_UPDATE_ALLOWED';

Line 171: x_return_status := OKC_API.G_RET_STS_SUCCESS;

167: okc_debug.Set_Indentation('Generate Contract Number');
168: okc_debug.log('1000: Entering generate contract number');
169: END IF;
170: -- initialize return status
171: x_return_status := OKC_API.G_RET_STS_SUCCESS;
172:
173: -- if contract number is null, polpulate default contract number
174: If (x_contract_number = OKC_API.G_MISS_CHAR or
175: x_contract_number is null)

Line 174: If (x_contract_number = OKC_API.G_MISS_CHAR or

170: -- initialize return status
171: x_return_status := OKC_API.G_RET_STS_SUCCESS;
172:
173: -- if contract number is null, polpulate default contract number
174: If (x_contract_number = OKC_API.G_MISS_CHAR or
175: x_contract_number is null)
176: Then
177: IF (l_debug = 'Y') THEN
178: okc_debug.log('1010: x_contract_Number is null');

Line 197: If (l_return_status <> OKC_API.G_RET_STS_SUCCESS) Then

193: okc_debug.log('1040: x_contract_number ' || x_contract_number);
194: END IF;
195:
196: x_return_status := l_return_status;
197: If (l_return_status <> OKC_API.G_RET_STS_SUCCESS) Then
198: Raise G_EXCEPTION_HALT_VALIDATION;
199: End If;
200:
201: -- check for unique contract_number + modifier

Line 206: If (l_return_status = OKC_API.G_RET_STS_SUCCESS) Then

202: /* l_chrv_rec.contract_number := x_contract_number;
203: l_chrv_rec.contract_number_modifier := p_modifier;
204:
205: l_return_status := OKC_CHR_PVT.Is_Unique(l_chrv_rec);
206: If (l_return_status = OKC_API.G_RET_STS_SUCCESS) Then
207: l_unique_number_found := TRUE;
208: End If;
209: x_return_status := l_return_status;
210: END LOOP; */

Line 223: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

219: okc_debug.log('1060: Exiting Generate Contract Number');
220: okc_debug.reset_indentation;
221: END IF;
222: when OTHERS then
223: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
224: OKC_API.SET_MESSAGE(p_app_name => g_app_name,
225: p_msg_name => g_unexpected_error,
226: p_token1 => g_sqlcode_token,
227: p_token1_value => sqlcode,

Line 224: OKC_API.SET_MESSAGE(p_app_name => g_app_name,

220: okc_debug.reset_indentation;
221: END IF;
222: when OTHERS then
223: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
224: OKC_API.SET_MESSAGE(p_app_name => g_app_name,
225: p_msg_name => g_unexpected_error,
226: p_token1 => g_sqlcode_token,
227: p_token1_value => sqlcode,
228: p_token2 => g_sqlerrm_token,

Line 248: x_return_status := OKC_API.G_RET_STS_SUCCESS;

244: l_cvmv_rec OKC_CVM_PVT.cvmv_rec_type;
245: BEGIN
246:
247: -- initialize return status
248: x_return_status := OKC_API.G_RET_STS_SUCCESS;
249:
250: -- assign/populate contract header id
251: l_cvmv_rec.chr_id := p_chr_id;
252:

Line 268: x_return_status := OKC_API.G_RET_STS_ERROR;

264: return (x_return_status);
265: EXCEPTION
266: when OTHERS then
267: -- notify caller of an error
268: x_return_status := OKC_API.G_RET_STS_ERROR;
269:
270: -- store SQL error message on message stack
271: OKC_API.SET_MESSAGE(p_app_name => g_app_name,
272: p_msg_name => g_unexpected_error,

Line 271: OKC_API.SET_MESSAGE(p_app_name => g_app_name,

267: -- notify caller of an error
268: x_return_status := OKC_API.G_RET_STS_ERROR;
269:
270: -- store SQL error message on message stack
271: OKC_API.SET_MESSAGE(p_app_name => g_app_name,
272: p_msg_name => g_unexpected_error,
273: p_token1 => g_sqlcode_token,
274: p_token1_value => sqlcode,
275: p_token2 => g_sqlerrm_token,

Line 299: x_return_status := OKC_API.G_RET_STS_SUCCESS;

295:
296: l_cvmv_rec OKC_CVM_PVT.cvmv_rec_type;
297: BEGIN
298:
299: x_return_status := OKC_API.G_RET_STS_SUCCESS;
300:
301: l_cvmv_rec.chr_id := p_chr_id;
302:
303: -- Major version update is not allowed

Line 304: l_cvmv_rec.major_version := OKC_API.G_MISS_NUM;

300:
301: l_cvmv_rec.chr_id := p_chr_id;
302:
303: -- Major version update is not allowed
304: l_cvmv_rec.major_version := OKC_API.G_MISS_NUM;
305:
306: -- update contract version number
307: OKC_CVM_PVT.update_row(
308: p_api_version,

Line 322: OKC_API.SET_MESSAGE(p_app_name => g_app_name,

318: return x_return_status;
319: EXCEPTION
320: WHEN OTHERS THEN
321: -- store SQL error message on message stack
322: OKC_API.SET_MESSAGE(p_app_name => g_app_name,
323: p_msg_name => g_unexpected_error,
324: p_token1 => g_sqlcode_token,
325: p_token1_value => sqlcode,
326: p_token2 => g_sqlerrm_token,

Line 329: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

325: p_token1_value => sqlcode,
326: p_token2 => g_sqlerrm_token,
327: p_token2_value => sqlerrm);
328:
329: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
330: return x_return_status;
331: END Increment_Minor_Version;
332:
333: FUNCTION Create_Version(p_chr_id IN NUMBER) RETURN VARCHAR2 Is

Line 344: x_return_status := OKC_API.G_RET_STS_SUCCESS;

340: l_cvmv_rec OKC_CVM_PVT.cvmv_rec_type;
341: BEGIN
342:
343: -- initialize return status
344: x_return_status := OKC_API.G_RET_STS_SUCCESS;
345:
346: -- assign/populate contract header id
347: l_cvmv_rec.chr_id := p_chr_id;
348:

Line 364: x_return_status := OKC_API.G_RET_STS_ERROR;

360: return (x_return_status);
361: EXCEPTION
362: when OTHERS then
363: -- notify caller of an error
364: x_return_status := OKC_API.G_RET_STS_ERROR;
365:
366: -- store SQL error message on message stack
367: OKC_API.SET_MESSAGE(p_app_name => g_app_name,
368: p_msg_name => g_unexpected_error,

Line 367: OKC_API.SET_MESSAGE(p_app_name => g_app_name,

363: -- notify caller of an error
364: x_return_status := OKC_API.G_RET_STS_ERROR;
365:
366: -- store SQL error message on message stack
367: OKC_API.SET_MESSAGE(p_app_name => g_app_name,
368: p_msg_name => g_unexpected_error,
369: p_token1 => g_sqlcode_token,
370: p_token1_value => sqlcode,
371: p_token2 => g_sqlerrm_token,

Line 387: x_return_status := OKC_API.G_RET_STS_SUCCESS;

383: l_cvmv_rec OKC_CVM_PVT.cvmv_rec_type;
384: BEGIN
385:
386: -- initialize return status
387: x_return_status := OKC_API.G_RET_STS_SUCCESS;
388:
389: -- assign/populate contract header id
390: l_cvmv_rec.chr_id := p_chr_id;
391:

Line 406: x_return_status := OKC_API.G_RET_STS_ERROR;

402: return (x_return_status);
403: EXCEPTION
404: when OTHERS then
405: -- notify caller of an error
406: x_return_status := OKC_API.G_RET_STS_ERROR;
407:
408: -- store SQL error message on message stack
409: OKC_API.SET_MESSAGE(p_app_name => g_app_name,
410: p_msg_name => g_unexpected_error,

Line 409: OKC_API.SET_MESSAGE(p_app_name => g_app_name,

405: -- notify caller of an error
406: x_return_status := OKC_API.G_RET_STS_ERROR;
407:
408: -- store SQL error message on message stack
409: OKC_API.SET_MESSAGE(p_app_name => g_app_name,
410: p_msg_name => g_unexpected_error,
411: p_token1 => g_sqlcode_token,
412: p_token1_value => sqlcode,
413: p_token2 => g_sqlerrm_token,

Line 446: x_return_status := OKC_API.G_RET_STS_SUCCESS;

442: WHERE chr_id=p_chr_id;
443:
444: BEGIN
445: -- initialize return status
446: x_return_status := OKC_API.G_RET_STS_SUCCESS;
447:
448: --if p_check_access is 'Y' , check if user has update access on category
449:
450: If (p_check_access = 'Y' AND

Line 460: If (l_chrv_rec.contract_number = OKC_API.G_MISS_CHAR or

456: RAISE G_CREATE_NA_EXCEPTION;
457: End If;
458:
459: -- if contract number is null, polpulate default contract number
460: If (l_chrv_rec.contract_number = OKC_API.G_MISS_CHAR or
461: l_chrv_rec.contract_number is null)
462: Then
463: OKC_CONTRACT_PVT.GENERATE_CONTRACT_NUMBER(
464: p_scs_code => l_chrv_rec.scs_code,

Line 469: /* If (x_return_status <> OKC_API.G_RET_STS_SUCCESS) Then

465: p_modifier => l_chrv_rec.contract_number_modifier,
466: x_return_status => x_return_status,
467: x_contract_number => l_chrv_rec.contract_number);
468:
469: /* If (x_return_status <> OKC_API.G_RET_STS_SUCCESS) Then
470: OKC_API.SET_MESSAGE(p_app_name => g_app_name,
471: p_msg_name => g_unexpected_error,
472: p_token1 => g_sqlcode_token,
473: p_token1_value => sqlcode,

Line 470: OKC_API.SET_MESSAGE(p_app_name => g_app_name,

466: x_return_status => x_return_status,
467: x_contract_number => l_chrv_rec.contract_number);
468:
469: /* If (x_return_status <> OKC_API.G_RET_STS_SUCCESS) Then
470: OKC_API.SET_MESSAGE(p_app_name => g_app_name,
471: p_msg_name => g_unexpected_error,
472: p_token1 => g_sqlcode_token,
473: p_token1_value => sqlcode,
474: p_token2 => g_sqlerrm_token,

Line 479: If (x_return_status = OKC_API.G_RET_STS_SUCCESS) Then

475: p_token2_value => sqlerrm);
476: End If; */
477: End If;
478:
479: If (x_return_status = OKC_API.G_RET_STS_SUCCESS) Then
480:
481: OKC_CHR_PVT.Insert_Row(
482: p_api_version => p_api_version,
483: p_init_msg_list => p_init_msg_list,

Line 492: If (x_return_status = OKC_API.G_RET_STS_SUCCESS) Then

488: x_chrv_rec => x_chrv_rec);
489: End If;
490:
491: -- Create version
492: If (x_return_status = OKC_API.G_RET_STS_SUCCESS) Then
493: x_return_status := OKC_CONTRACT_PVT.Create_Version(x_chrv_rec.id);
494: End If;
495:
496: -- Create record in OKC_K_HISTORY tables

Line 497: If (x_return_status = OKC_API.G_RET_STS_SUCCESS) Then

493: x_return_status := OKC_CONTRACT_PVT.Create_Version(x_chrv_rec.id);
494: End If;
495:
496: -- Create record in OKC_K_HISTORY tables
497: If (x_return_status = OKC_API.G_RET_STS_SUCCESS) Then
498: l_hstv_rec.chr_id := x_chrv_rec.id;
499: l_hstv_rec.sts_code_from := NULL;
500: l_hstv_rec.sts_code_to := x_chrv_rec.sts_code;
501: l_hstv_rec.reason_code := 'CREATE';

Line 523: OKC_API.SET_MESSAGE(p_app_name => 'OKC',

519: End If;
520:
521: EXCEPTION
522: When G_CREATE_NA_EXCEPTION Then
523: OKC_API.SET_MESSAGE(p_app_name => 'OKC',
524: p_msg_name => 'OKC_CREATE_NA',
525: p_token1 => 'CATEGORY',
526: p_token1_value => l_scs_meaning);
527: x_return_status:=OKC_API.G_RET_STS_ERROR;

Line 527: x_return_status:=OKC_API.G_RET_STS_ERROR;

523: OKC_API.SET_MESSAGE(p_app_name => 'OKC',
524: p_msg_name => 'OKC_CREATE_NA',
525: p_token1 => 'CATEGORY',
526: p_token1_value => l_scs_meaning);
527: x_return_status:=OKC_API.G_RET_STS_ERROR;
528:
529: END create_contract_header;
530:
531: PROCEDURE create_contract_header(

Line 597: If (p_restricted_update <> OKC_API.G_TRUE) Then

593:
594: BEGIN
595: -- if the update is not a restricted update (restricted_update <> 'Y'),
596: -- check whether update is allowed or not
597: If (p_restricted_update <> OKC_API.G_TRUE) Then
598: If (OKC_CONTRACT_PUB.Update_Allowed(p_chrv_rec.id) <> 'Y') Then
599: raise G_NO_UPDATE_ALLOWED_EXCEPTION;
600: End If;
601: End If;

Line 614: If (p_chrv_rec.sts_code = OKC_API.G_MISS_CHAR) Then

610: open l_status_csr;
611: fetch l_status_csr into l_status;
612: close l_status_csr;
613:
614: If (p_chrv_rec.sts_code = OKC_API.G_MISS_CHAR) Then
615: l_new_status := NULL;
616: Else
617: l_new_status := p_chrv_rec.sts_code;
618: End If;

Line 632: If x_return_status = OKC_API.G_RET_STS_SUCCESS THEN

628: x_chrv_rec => x_chrv_rec);
629:
630: -- Update minor version
631: /*fix for bug6688656*/
632: If x_return_status = OKC_API.G_RET_STS_SUCCESS THEN
633: x_return_status := Update_Minor_Version(p_chrv_rec.id);
634: End if;
635: /*end of fix for bug6688656*/
636:

Line 638: If (x_return_status = OKC_API.G_RET_STS_SUCCESS AND

634: End if;
635: /*end of fix for bug6688656*/
636:
637: -- Call action assembler if status is changed
638: If (x_return_status = OKC_API.G_RET_STS_SUCCESS AND
639: p_chrv_rec.old_sts_code is not null AND
640: p_chrv_rec.new_sts_code is not null AND
641: p_chrv_rec.old_ste_code is not null AND
642: p_chrv_rec.new_ste_code is not null AND

Line 663: If ( ( (x_return_status = OKC_API.G_RET_STS_SUCCESS) AND (l_new_status is not null) AND (l_status is not null) )

659: p_k_pre_sts_code => p_chrv_rec.old_sts_code,
660: p_k_pre_sts_type => p_chrv_rec.old_ste_code,
661: p_k_source_system_code => p_chrv_rec.ORIG_SYSTEM_SOURCE_CODE);
662: Else
663: If ( ( (x_return_status = OKC_API.G_RET_STS_SUCCESS) AND (l_new_status is not null) AND (l_status is not null) )
664: AND (l_status <> l_new_status) ) Then
665:
666: -- To insert record in history tables
667: l_hstv_rec.chr_id := x_chrv_rec.id;

Line 690: If (x_return_status = OKC_API.G_RET_STS_SUCCESS) Then

686: End If;
687: End If;
688:
689: -- Update Currency change
690: If (x_return_status = OKC_API.G_RET_STS_SUCCESS) Then
691: -- If currency code changed, update all lines
692: If (x_chrv_rec.currency_code <> l_currency_code) Then
693: UPDATE okc_k_lines_b
694: SET currency_code = x_chrv_rec.currency_code

Line 703: x_return_status := OKC_API.G_RET_STS_ERROR;

699: */
700: End If;
701: exception
702: when G_NO_UPDATE_ALLOWED_EXCEPTION then
703: x_return_status := OKC_API.G_RET_STS_ERROR;
704: OKC_API.SET_MESSAGE(p_app_name => g_app_name,
705: p_msg_name => g_no_update_allowed,
706: p_token1 => 'VALUE1',
707: p_token1_value => 'Contract Header');

Line 704: OKC_API.SET_MESSAGE(p_app_name => g_app_name,

700: End If;
701: exception
702: when G_NO_UPDATE_ALLOWED_EXCEPTION then
703: x_return_status := OKC_API.G_RET_STS_ERROR;
704: OKC_API.SET_MESSAGE(p_app_name => g_app_name,
705: p_msg_name => g_no_update_allowed,
706: p_token1 => 'VALUE1',
707: p_token1_value => 'Contract Header');
708: when OTHERS then

Line 710: OKC_API.SET_MESSAGE(p_app_name => g_app_name,

706: p_token1 => 'VALUE1',
707: p_token1_value => 'Contract Header');
708: when OTHERS then
709: -- store SQL error message on message stack
710: OKC_API.SET_MESSAGE(p_app_name => g_app_name,
711: p_msg_name => g_unexpected_error,
712: p_token1 => g_sqlcode_token,
713: p_token1_value => sqlcode,
714: p_token2 => g_sqlerrm_token,

Line 718: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

714: p_token2 => g_sqlerrm_token,
715: p_token2_value => sqlerrm);
716:
717: -- notify caller of an UNEXPETED error
718: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
719: END update_contract_header;
720:
721:
722: PROCEDURE update_contract_header(

Line 789: If (p_restricted_update <> OKC_API.G_TRUE) Then

785:
786: BEGIN
787: -- if the update is not a restricted update (restricted_update <> 'Y'),
788: -- check whether update is allowed or not
789: If (p_restricted_update <> OKC_API.G_TRUE) Then
790: If (OKC_CONTRACT_PUB.Update_Allowed(p_chrv_rec.id) <> 'Y') Then
791: raise G_NO_UPDATE_ALLOWED_EXCEPTION;
792: End If;
793: End If;

Line 806: If (p_chrv_rec.sts_code = OKC_API.G_MISS_CHAR) Then

802: open l_status_csr;
803: fetch l_status_csr into l_status;
804: close l_status_csr;
805:
806: If (p_chrv_rec.sts_code = OKC_API.G_MISS_CHAR) Then
807: l_new_status := NULL;
808: Else
809: l_new_status := p_chrv_rec.sts_code;
810: End If;

Line 824: If x_return_status = OKC_API.G_RET_STS_SUCCESS THEN

820: x_chrv_rec => x_chrv_rec);
821:
822: -- Update minor version
823: /*fix for bug6688656*/
824: If x_return_status = OKC_API.G_RET_STS_SUCCESS THEN
825: x_return_status := Update_Minor_Version(p_chrv_rec.id);
826: End if;
827: /*end of fix for bug6688656*/
828:

Line 830: If (x_return_status = OKC_API.G_RET_STS_SUCCESS AND

826: End if;
827: /*end of fix for bug6688656*/
828:
829: -- Call action assembler if status is changed
830: If (x_return_status = OKC_API.G_RET_STS_SUCCESS AND
831: p_chrv_rec.old_sts_code is not null AND
832: p_chrv_rec.new_sts_code is not null AND
833: p_chrv_rec.old_ste_code is not null AND
834: p_chrv_rec.new_ste_code is not null AND

Line 856: If ( ( (x_return_status = OKC_API.G_RET_STS_SUCCESS) AND (l_new_status is not null) AND (l_status is not null) )

852: p_k_pre_sts_type => p_chrv_rec.old_ste_code,
853: p_k_source_system_code => p_chrv_rec.ORIG_SYSTEM_SOURCE_CODE,
854: p_control_rec => p_control_rec);
855: Else
856: If ( ( (x_return_status = OKC_API.G_RET_STS_SUCCESS) AND (l_new_status is not null) AND (l_status is not null) )
857: AND (l_status <> l_new_status) ) Then
858:
859: -- To insert record in history tables
860: l_hstv_rec.chr_id := x_chrv_rec.id;

Line 883: If (x_return_status = OKC_API.G_RET_STS_SUCCESS) Then

879: End If;
880: End If;
881:
882: -- Update Currency change
883: If (x_return_status = OKC_API.G_RET_STS_SUCCESS) Then
884: -- If currency code changed, update all lines
885: If (x_chrv_rec.currency_code <> l_currency_code) Then
886: UPDATE okc_k_lines_b
887: SET currency_code = x_chrv_rec.currency_code

Line 896: x_return_status := OKC_API.G_RET_STS_ERROR;

892: */
893: End If;
894: exception
895: when G_NO_UPDATE_ALLOWED_EXCEPTION then
896: x_return_status := OKC_API.G_RET_STS_ERROR;
897: OKC_API.SET_MESSAGE(p_app_name => g_app_name,
898: p_msg_name => g_no_update_allowed,
899: p_token1 => 'VALUE1',
900: p_token1_value => 'Contract Header');

Line 897: OKC_API.SET_MESSAGE(p_app_name => g_app_name,

893: End If;
894: exception
895: when G_NO_UPDATE_ALLOWED_EXCEPTION then
896: x_return_status := OKC_API.G_RET_STS_ERROR;
897: OKC_API.SET_MESSAGE(p_app_name => g_app_name,
898: p_msg_name => g_no_update_allowed,
899: p_token1 => 'VALUE1',
900: p_token1_value => 'Contract Header');
901: when OTHERS then

Line 903: OKC_API.SET_MESSAGE(p_app_name => g_app_name,

899: p_token1 => 'VALUE1',
900: p_token1_value => 'Contract Header');
901: when OTHERS then
902: -- store SQL error message on message stack
903: OKC_API.SET_MESSAGE(p_app_name => g_app_name,
904: p_msg_name => g_unexpected_error,
905: p_token1 => g_sqlcode_token,
906: p_token1_value => sqlcode,
907: p_token2 => g_sqlerrm_token,

Line 911: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

907: p_token2 => g_sqlerrm_token,
908: p_token2_value => sqlerrm);
909:
910: -- notify caller of an UNEXPETED error
911: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
912: END update_contract_header;
913:
914: PROCEDURE delete_contract_header(
915: p_api_version IN NUMBER,

Line 1018: OKC_API.SET_MESSAGE(p_app_name => g_app_name,

1014: x_msg_count => x_msg_count,
1015: x_msg_data => x_msg_data,
1016: p_chrv_rec => p_chrv_rec);
1017: Else
1018: OKC_API.SET_MESSAGE(p_app_name => g_app_name,
1019: p_msg_name => g_no_parent_record,
1020: p_token1 => g_child_table_token,
1021: p_token1_value => 'OKC_K_LINES_V',
1022: p_token2 => g_parent_table_token,

Line 1025: x_return_status := OKC_API.G_RET_STS_ERROR;

1021: p_token1_value => 'OKC_K_LINES_V',
1022: p_token2 => g_parent_table_token,
1023: p_token2_value => 'OKC_K_HEADERS_V');
1024: -- notify caller of an error
1025: x_return_status := OKC_API.G_RET_STS_ERROR;
1026: End If;
1027:
1028: -- Delete operation instances (renewal links)
1029: If (x_return_status = OKC_API.G_RET_STS_SUCCESS) Then

Line 1029: If (x_return_status = OKC_API.G_RET_STS_SUCCESS) Then

1025: x_return_status := OKC_API.G_RET_STS_ERROR;
1026: End If;
1027:
1028: -- Delete operation instances (renewal links)
1029: If (x_return_status = OKC_API.G_RET_STS_SUCCESS) Then
1030: FOR oie_rec IN oie_csr
1031: LOOP
1032: i := i + 1;
1033: l_oiev_tbl(i).ID := oie_rec.ID;

Line 1048: If (x_return_status = OKC_API.G_RET_STS_SUCCESS) Then

1044: End if;
1045: End if;
1046:
1047: -- Delete relationships with header and other objects
1048: If (x_return_status = OKC_API.G_RET_STS_SUCCESS) Then
1049: For c In l_crjv_csr
1050: Loop
1051: l_crjv_rec.id := c.id;
1052: l_crjv_rec.object_version_number := c.object_version_number;

Line 1073: If (x_return_status = OKC_API.G_RET_STS_SUCCESS) Then

1069: fetch l_cvm_csr into l_major_version;
1070: close l_cvm_csr;
1071:
1072: -- Delete any attachments assiciated
1073: If (x_return_status = OKC_API.G_RET_STS_SUCCESS) Then
1074: If (fnd_attachment_util_pkg.get_atchmt_exists (
1075: l_entity_name => 'OKC_K_HEADERS_B',
1076: l_pkey1 => p_chrv_rec.id,
1077: l_pkey2 => l_major_version) = 'Y')

Line 1094: If (x_return_status = OKC_API.G_RET_STS_SUCCESS) Then

1090: End If;
1091: End If;
1092:
1093: -- Delete version
1094: If (x_return_status = OKC_API.G_RET_STS_SUCCESS) Then
1095: x_return_status := Delete_Version(p_chrv_rec.id);
1096: End If;
1097: exception
1098: when G_NO_UPDATE_ALLOWED_EXCEPTION then

Line 1099: x_return_status := OKC_API.G_RET_STS_ERROR;

1095: x_return_status := Delete_Version(p_chrv_rec.id);
1096: End If;
1097: exception
1098: when G_NO_UPDATE_ALLOWED_EXCEPTION then
1099: x_return_status := OKC_API.G_RET_STS_ERROR;
1100: OKC_API.SET_MESSAGE(p_app_name => g_app_name,
1101: p_msg_name => g_no_update_allowed,
1102: p_token1 => 'VALUE1',
1103: p_token1_value => 'Contract Header');

Line 1100: OKC_API.SET_MESSAGE(p_app_name => g_app_name,

1096: End If;
1097: exception
1098: when G_NO_UPDATE_ALLOWED_EXCEPTION then
1099: x_return_status := OKC_API.G_RET_STS_ERROR;
1100: OKC_API.SET_MESSAGE(p_app_name => g_app_name,
1101: p_msg_name => g_no_update_allowed,
1102: p_token1 => 'VALUE1',
1103: p_token1_value => 'Contract Header');
1104: when OTHERS then

Line 1106: OKC_API.SET_MESSAGE(p_app_name => g_app_name,

1102: p_token1 => 'VALUE1',
1103: p_token1_value => 'Contract Header');
1104: when OTHERS then
1105: -- store SQL error message on message stack
1106: OKC_API.SET_MESSAGE(p_app_name => g_app_name,
1107: p_msg_name => g_unexpected_error,
1108: p_token1 => g_sqlcode_token,
1109: p_token1_value => sqlcode,
1110: p_token2 => g_sqlerrm_token,

Line 1114: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

1110: p_token2 => g_sqlerrm_token,
1111: p_token2_value => sqlerrm);
1112:
1113: -- notify caller of an UNEXPETED error
1114: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
1115: END delete_contract_header;
1116:
1117: PROCEDURE delete_contract_header(
1118: p_api_version IN NUMBER,

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

1213: p_clev_rec IN OKC_CLE_PVT.clev_rec_type) Is
1214:
1215: l_acyv_rec OKC_ACY_PVT.acyv_rec_type;
1216: l_out_rec OKC_ACY_PVT.acyv_rec_type;
1217: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1218:
1219: -- cursor to get the next level_sequence
1220: Cursor l_acyv_csr Is
1221: select NVL(MAX(level_sequence),0) + 1

Line 1232: x_return_status := OKC_API.G_RET_STS_SUCCESS;

1228: from OKC_ANCESTRYS
1229: where cle_id = p_clev_rec.cle_id;
1230:
1231: BEGIN
1232: x_return_status := OKC_API.G_RET_STS_SUCCESS;
1233: -- insert ancestry, if line record has a parent line record
1234: If (p_clev_rec.cle_id <> OKC_API.G_MISS_NUM and
1235: p_clev_rec.cle_id is not null)
1236: Then

Line 1234: If (p_clev_rec.cle_id <> OKC_API.G_MISS_NUM and

1230:
1231: BEGIN
1232: x_return_status := OKC_API.G_RET_STS_SUCCESS;
1233: -- insert ancestry, if line record has a parent line record
1234: If (p_clev_rec.cle_id <> OKC_API.G_MISS_NUM and
1235: p_clev_rec.cle_id is not null)
1236: Then
1237: -- get next level sequence
1238: open l_acyv_csr;

Line 1258: If (l_return_status = OKC_API.G_RET_STS_SUCCESS) Then

1254:
1255: -- if the current insert is success,
1256: -- copy all other existing ancestry records of
1257: -- parent line (p_clev_rec.cle_id)
1258: If (l_return_status = OKC_API.G_RET_STS_SUCCESS) Then
1259: open l_acyv_csr2;
1260:
1261: -- fetch first record
1262: fetch l_acyv_csr2 into l_acyv_rec.cle_id_ascendant,

Line 1285: OKC_API.SET_MESSAGE(p_app_name => g_app_name,

1281: End If;
1282: exception
1283: when OTHERS then
1284: -- store SQL error message on message stack
1285: OKC_API.SET_MESSAGE(p_app_name => g_app_name,
1286: p_msg_name => g_unexpected_error,
1287: p_token1 => g_sqlcode_token,
1288: p_token1_value => sqlcode,
1289: p_token2 => g_sqlerrm_token,

Line 1293: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

1289: p_token2 => g_sqlerrm_token,
1290: p_token2_value => sqlerrm);
1291:
1292: -- notify caller of an UNEXPETED error
1293: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
1294:
1295: -- verify that cursors were closed
1296: if l_acyv_csr%ISOPEN then
1297: close l_acyv_csr;

Line 1320: x_return_status := OKC_API.G_RET_STS_SUCCESS;

1316: FROM OKC_K_LINES_B
1317: WHERE id = p_clev_rec.id;
1318: BEGIN
1319: -- initialize return status
1320: x_return_status := OKC_API.G_RET_STS_SUCCESS;
1321: -- if dnz_chr_id is present, return it
1322: If (p_clev_rec.dnz_chr_id is not null and
1323: p_clev_rec.dnz_chr_id <> OKC_API.G_MISS_NUM)
1324: Then

Line 1323: p_clev_rec.dnz_chr_id <> OKC_API.G_MISS_NUM)

1319: -- initialize return status
1320: x_return_status := OKC_API.G_RET_STS_SUCCESS;
1321: -- if dnz_chr_id is present, return it
1322: If (p_clev_rec.dnz_chr_id is not null and
1323: p_clev_rec.dnz_chr_id <> OKC_API.G_MISS_NUM)
1324: Then
1325: x_chr_id := p_clev_rec.dnz_chr_id;
1326: Else
1327: -- else if chr_id is present , return it

Line 1329: p_clev_rec.chr_id <> OKC_API.G_MISS_NUM)

1325: x_chr_id := p_clev_rec.dnz_chr_id;
1326: Else
1327: -- else if chr_id is present , return it
1328: If (p_clev_rec.chr_id is not null and
1329: p_clev_rec.chr_id <> OKC_API.G_MISS_NUM)
1330: Then
1331: x_chr_id := p_clev_rec.chr_id;
1332: Else
1333: -- else get header id from database

Line 1338: x_return_status := OKC_API.G_RET_STS_ERROR;

1334: Open l_clev_csr;
1335: Fetch l_clev_csr into x_chr_id;
1336: If (l_clev_csr%NOTFOUND) Then
1337: Close l_clev_csr;
1338: x_return_status := OKC_API.G_RET_STS_ERROR;
1339: RAISE OKC_API.G_EXCEPTION_ERROR;
1340: End If;
1341: Close l_clev_csr;
1342: End If;

Line 1339: RAISE OKC_API.G_EXCEPTION_ERROR;

1335: Fetch l_clev_csr into x_chr_id;
1336: If (l_clev_csr%NOTFOUND) Then
1337: Close l_clev_csr;
1338: x_return_status := OKC_API.G_RET_STS_ERROR;
1339: RAISE OKC_API.G_EXCEPTION_ERROR;
1340: End If;
1341: Close l_clev_csr;
1342: End If;
1343: End If;

Line 1345: WHEN OKC_API.G_EXCEPTION_ERROR THEN

1341: Close l_clev_csr;
1342: End If;
1343: End If;
1344: exception
1345: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1346: OKC_API.SET_MESSAGE(p_app_name => g_app_name,
1347: p_msg_name => g_unexpected_error,
1348: p_token1 => g_sqlcode_token,
1349: p_token1_value => sqlcode,

Line 1346: OKC_API.SET_MESSAGE(p_app_name => g_app_name,

1342: End If;
1343: End If;
1344: exception
1345: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1346: OKC_API.SET_MESSAGE(p_app_name => g_app_name,
1347: p_msg_name => g_unexpected_error,
1348: p_token1 => g_sqlcode_token,
1349: p_token1_value => sqlcode,
1350: p_token2 => g_sqlerrm_token,

Line 1352: x_return_status :=OKC_API.G_RET_STS_ERROR;

1348: p_token1 => g_sqlcode_token,
1349: p_token1_value => sqlcode,
1350: p_token2 => g_sqlerrm_token,
1351: p_token2_value => sqlerrm);
1352: x_return_status :=OKC_API.G_RET_STS_ERROR;
1353:
1354: when OTHERS then
1355: -- store SQL error message on message stack
1356: OKC_API.SET_MESSAGE(p_app_name => g_app_name,

Line 1356: OKC_API.SET_MESSAGE(p_app_name => g_app_name,

1352: x_return_status :=OKC_API.G_RET_STS_ERROR;
1353:
1354: when OTHERS then
1355: -- store SQL error message on message stack
1356: OKC_API.SET_MESSAGE(p_app_name => g_app_name,
1357: p_msg_name => g_unexpected_error,
1358: p_token1 => g_sqlcode_token,
1359: p_token1_value => sqlcode,
1360: p_token2 => g_sqlerrm_token,

Line 1364: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

1360: p_token2 => g_sqlerrm_token,
1361: p_token2_value => sqlerrm);
1362:
1363: -- notify caller of an UNEXPETED error
1364: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
1365: END Get_Contract_Id;
1366:
1367: PROCEDURE create_contract_line(
1368: p_api_version IN NUMBER,

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

1373: p_restricted_update IN VARCHAR2 ,
1374: p_clev_rec IN OKC_CLE_PVT.clev_rec_type,
1375: x_clev_rec OUT NOCOPY OKC_CLE_PVT.clev_rec_type) IS
1376:
1377: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1378: l_chr_id NUMBER;
1379: BEGIN
1380: -- check whether the contract is updateable or not
1381: OKC_CONTRACT_PVT.Get_Contract_Id(

Line 1386: If (l_return_status = OKC_API.G_RET_STS_SUCCESS) Then

1382: p_clev_rec => p_clev_rec,
1383: x_chr_id => l_chr_id,
1384: x_return_status => l_return_status);
1385:
1386: If (l_return_status = OKC_API.G_RET_STS_SUCCESS) Then
1387: -- if the update is not a restricted update (restricted_update <> 'Y'),
1388: -- check whether update is allowed or not
1389: If (p_restricted_update <> OKC_API.G_TRUE) Then
1390: If (OKC_CONTRACT_PUB.Update_Allowed(l_chr_id) <> 'Y') Then

Line 1389: If (p_restricted_update <> OKC_API.G_TRUE) Then

1385:
1386: If (l_return_status = OKC_API.G_RET_STS_SUCCESS) Then
1387: -- if the update is not a restricted update (restricted_update <> 'Y'),
1388: -- check whether update is allowed or not
1389: If (p_restricted_update <> OKC_API.G_TRUE) Then
1390: If (OKC_CONTRACT_PUB.Update_Allowed(l_chr_id) <> 'Y') Then
1391: raise G_NO_UPDATE_ALLOWED_EXCEPTION;
1392: End If;
1393: End If;

Line 1395: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1391: raise G_NO_UPDATE_ALLOWED_EXCEPTION;
1392: End If;
1393: End If;
1394: Else
1395: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1396: End If;
1397:
1398: OKC_CLE_PVT.Insert_Row(
1399: p_api_version => p_api_version,

Line 1407: If (x_return_status = OKC_API.G_RET_STS_SUCCESS) Then

1403: x_msg_data => x_msg_data,
1404: p_clev_rec => p_clev_rec,
1405: x_clev_rec => x_clev_rec);
1406: -- if the above process is success, create ancestry
1407: If (x_return_status = OKC_API.G_RET_STS_SUCCESS) Then
1408: x_clev_rec.cle_id := p_clev_rec.cle_id;
1409: create_ancestry(
1410: p_api_version => p_api_version,
1411: p_init_msg_list => p_init_msg_list,

Line 1421: If (l_return_status = OKC_API.G_RET_STS_SUCCESS) Then

1417: raise G_EXCEPTION_HALT_PROCESS;
1418: End If;
1419:
1420: -- Update minor version
1421: If (l_return_status = OKC_API.G_RET_STS_SUCCESS) Then
1422: x_return_status := Update_Minor_Version(x_clev_rec.dnz_chr_id);
1423: End If;
1424: exception
1425: when G_EXCEPTION_HALT_PROCESS then

Line 1429: OKC_API.SET_MESSAGE(p_app_name => g_app_name,

1425: when G_EXCEPTION_HALT_PROCESS then
1426: null;
1427:
1428: when G_NO_UPDATE_ALLOWED_EXCEPTION then
1429: OKC_API.SET_MESSAGE(p_app_name => g_app_name,
1430: p_msg_name => g_no_update_allowed,
1431: p_token1 => 'VALUE1',
1432: p_token1_value => 'Contract Lines');
1433:

Line 1435: x_return_status := OKC_API.G_RET_STS_ERROR;

1431: p_token1 => 'VALUE1',
1432: p_token1_value => 'Contract Lines');
1433:
1434: -- notify caller of an error
1435: x_return_status := OKC_API.G_RET_STS_ERROR;
1436: when OTHERS then
1437: -- store SQL error message on message stack
1438: OKC_API.SET_MESSAGE(p_app_name => g_app_name,
1439: p_msg_name => g_unexpected_error,

Line 1438: OKC_API.SET_MESSAGE(p_app_name => g_app_name,

1434: -- notify caller of an error
1435: x_return_status := OKC_API.G_RET_STS_ERROR;
1436: when OTHERS then
1437: -- store SQL error message on message stack
1438: OKC_API.SET_MESSAGE(p_app_name => g_app_name,
1439: p_msg_name => g_unexpected_error,
1440: p_token1 => g_sqlcode_token,
1441: p_token1_value => sqlcode,
1442: p_token2 => g_sqlerrm_token,

Line 1446: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

1442: p_token2 => g_sqlerrm_token,
1443: p_token2_value => sqlerrm);
1444:
1445: -- notify caller of an UNEXPETED error
1446: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
1447: END create_contract_line;
1448:
1449: PROCEDURE create_contract_line(
1450: p_api_version IN NUMBER,

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

1475: p_restricted_update IN VARCHAR2 ,
1476: p_clev_rec IN OKC_CLE_PVT.clev_rec_type,
1477: x_clev_rec OUT NOCOPY OKC_CLE_PVT.clev_rec_type) IS
1478:
1479: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1480: l_chr_id NUMBER;
1481: l_api_name CONSTANT VARCHAR2(30) := 'Update_Contract_Line';
1482:
1483: l_contract_number VARCHAR2(120);

Line 1500: If (l_return_status = OKC_API.G_RET_STS_SUCCESS) Then

1496: p_clev_rec => p_clev_rec,
1497: x_chr_id => l_chr_id,
1498: x_return_status => l_return_status);
1499:
1500: If (l_return_status = OKC_API.G_RET_STS_SUCCESS) Then
1501: -- if the update is not a restricted update (restricted_update <> 'Y'),
1502: -- check whether update is allowed or not
1503: If (p_restricted_update <> OKC_API.G_TRUE) Then
1504: If (OKC_CONTRACT_PUB.Update_Allowed(l_chr_id) <> 'Y') Then

Line 1503: If (p_restricted_update <> OKC_API.G_TRUE) Then

1499:
1500: If (l_return_status = OKC_API.G_RET_STS_SUCCESS) Then
1501: -- if the update is not a restricted update (restricted_update <> 'Y'),
1502: -- check whether update is allowed or not
1503: If (p_restricted_update <> OKC_API.G_TRUE) Then
1504: If (OKC_CONTRACT_PUB.Update_Allowed(l_chr_id) <> 'Y') Then
1505: raise G_NO_UPDATE_ALLOWED_EXCEPTION;
1506: End If;
1507: End If;

Line 1509: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1505: raise G_NO_UPDATE_ALLOWED_EXCEPTION;
1506: End If;
1507: End If;
1508: Else
1509: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1510: End If;
1511: OKC_CLE_PVT.Update_Row(
1512: p_api_version => p_api_version,
1513: p_init_msg_list => p_init_msg_list,

Line 1522: If (x_return_status = OKC_API.G_RET_STS_SUCCESS AND

1518: p_clev_rec => p_clev_rec,
1519: x_clev_rec => x_clev_rec);
1520:
1521: -- Call action assembler if status is changed
1522: If (x_return_status = OKC_API.G_RET_STS_SUCCESS AND
1523: NVL(p_clev_rec.Call_Action_Asmblr,'Y') = 'Y' AND
1524: p_clev_rec.old_sts_code is not null AND
1525: p_clev_rec.new_sts_code is not null AND
1526: p_clev_rec.old_ste_code is not null AND

Line 1556: If (x_return_status = OKC_API.G_RET_STS_SUCCESS) Then

1552: p_kl_source_system_code => p_clev_rec.ORIG_SYSTEM_SOURCE_CODE);
1553: End If;
1554:
1555: -- Update minor version
1556: If (x_return_status = OKC_API.G_RET_STS_SUCCESS) Then
1557: x_return_status := Update_Minor_Version(x_clev_rec.dnz_chr_id);
1558: End If;
1559: exception
1560: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

Line 1560: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

1556: If (x_return_status = OKC_API.G_RET_STS_SUCCESS) Then
1557: x_return_status := Update_Minor_Version(x_clev_rec.dnz_chr_id);
1558: End If;
1559: exception
1560: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1561: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1562: (
1563: l_api_name,
1564: G_PKG_NAME,

Line 1561: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

1557: x_return_status := Update_Minor_Version(x_clev_rec.dnz_chr_id);
1558: End If;
1559: exception
1560: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1561: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1562: (
1563: l_api_name,
1564: G_PKG_NAME,
1565: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 1565: 'OKC_API.G_RET_STS_UNEXP_ERROR',

1561: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1562: (
1563: l_api_name,
1564: G_PKG_NAME,
1565: 'OKC_API.G_RET_STS_UNEXP_ERROR',
1566: x_msg_count,
1567: x_msg_data,
1568: '_PVT'
1569: );

Line 1571: OKC_API.SET_MESSAGE(p_app_name => g_app_name,

1567: x_msg_data,
1568: '_PVT'
1569: );
1570: when G_NO_UPDATE_ALLOWED_EXCEPTION then
1571: OKC_API.SET_MESSAGE(p_app_name => g_app_name,
1572: p_msg_name => g_no_update_allowed,
1573: p_token1 => 'VALUE1',
1574: p_token1_value => 'Contract Lines');
1575:

Line 1577: x_return_status := OKC_API.G_RET_STS_ERROR;

1573: p_token1 => 'VALUE1',
1574: p_token1_value => 'Contract Lines');
1575:
1576: -- notify caller of an error
1577: x_return_status := OKC_API.G_RET_STS_ERROR;
1578: when OTHERS then
1579: -- store SQL error message on message stack
1580: OKC_API.SET_MESSAGE(p_app_name => g_app_name,
1581: p_msg_name => g_unexpected_error,

Line 1580: OKC_API.SET_MESSAGE(p_app_name => g_app_name,

1576: -- notify caller of an error
1577: x_return_status := OKC_API.G_RET_STS_ERROR;
1578: when OTHERS then
1579: -- store SQL error message on message stack
1580: OKC_API.SET_MESSAGE(p_app_name => g_app_name,
1581: p_msg_name => g_unexpected_error,
1582: p_token1 => g_sqlcode_token,
1583: p_token1_value => sqlcode,
1584: p_token2 => g_sqlerrm_token,

Line 1588: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

1584: p_token2 => g_sqlerrm_token,
1585: p_token2_value => sqlerrm);
1586:
1587: -- notify caller of an UNEXPETED error
1588: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
1589: END update_contract_line;
1590:
1591: PROCEDURE update_contract_line(
1592: p_api_version IN NUMBER,

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

1619: p_cle_id IN NUMBER) Is
1620:
1621: l_acyv_rec OKC_ACY_PVT.acyv_rec_type;
1622: l_out_rec OKC_ACY_PVT.acyv_rec_type;
1623: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1624:
1625: -- cursor to get ancestry records to delete
1626: Cursor l_acyv_csr Is
1627: select cle_id, cle_id_ascendant

Line 1633: If (p_cle_id <> OKC_API.G_MISS_NUM and

1629: where cle_id = p_cle_id;
1630:
1631: BEGIN
1632: -- delete all ancestry records if p_cle_id is not null
1633: If (p_cle_id <> OKC_API.G_MISS_NUM and
1634: p_cle_id is not null)
1635: Then
1636: open l_acyv_csr;
1637:

Line 1650: If (l_return_status <> OKC_API.G_RET_STS_SUCCESS) Then

1646: x_return_status => l_return_status,
1647: x_msg_count => x_msg_count,
1648: x_msg_data => x_msg_data,
1649: p_acyv_rec => l_acyv_rec);
1650: If (l_return_status <> OKC_API.G_RET_STS_SUCCESS) Then
1651: raise G_EXCEPTION_HALT_VALIDATION;
1652: End If;
1653: -- fetch next record
1654: fetch l_acyv_csr into l_acyv_rec.cle_id,

Line 1663: OKC_API.SET_MESSAGE(p_app_name => g_app_name,

1659: End If;
1660: exception
1661: when G_EXCEPTION_HALT_VALIDATION then
1662: -- store SQL error message on message stack
1663: OKC_API.SET_MESSAGE(p_app_name => g_app_name,
1664: p_msg_name => g_unexpected_error,
1665: p_token1 => g_sqlcode_token,
1666: p_token1_value => sqlcode,
1667: p_token2 => g_sqlerrm_token,

Line 1673: OKC_API.SET_MESSAGE(p_app_name => g_app_name,

1669: x_return_status := l_return_status;
1670:
1671: when OTHERS then
1672: -- store SQL error message on message stack
1673: OKC_API.SET_MESSAGE(p_app_name => g_app_name,
1674: p_msg_name => g_unexpected_error,
1675: p_token1 => g_sqlcode_token,
1676: p_token1_value => sqlcode,
1677: p_token2 => g_sqlerrm_token,

Line 1681: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

1677: p_token2 => g_sqlerrm_token,
1678: p_token2_value => sqlerrm);
1679:
1680: -- notify caller of an UNEXPETED error
1681: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
1682:
1683: -- verify that cursor was closed
1684: if l_acyv_csr%ISOPEN then
1685: close l_acyv_csr;

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

1694: x_msg_count OUT NOCOPY NUMBER,
1695: x_msg_data OUT NOCOPY VARCHAR2,
1696: p_clev_rec IN OKC_CLE_PVT.clev_rec_type) IS
1697:
1698: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1699: l_chr_id NUMBER;
1700: l_dummy_val NUMBER;
1701: l_major_version FND_ATTACHED_DOCUMENTS.PK2_VALUE%TYPE;
1702:

Line 1765: If (l_return_status = OKC_API.G_RET_STS_SUCCESS) Then

1761: p_clev_rec => p_clev_rec,
1762: x_chr_id => l_chr_id,
1763: x_return_status => l_return_status);
1764:
1765: If (l_return_status = OKC_API.G_RET_STS_SUCCESS) Then
1766: If (OKC_CONTRACT_PUB.Update_Allowed(l_chr_id) <> 'Y') Then
1767: raise G_NO_UPDATE_ALLOWED_EXCEPTION;
1768: End If;
1769: End If;

Line 1794: If (x_return_status = OKC_API.G_RET_STS_SUCCESS) Then

1790: x_msg_data => x_msg_data,
1791: p_clev_rec => p_clev_rec);
1792:
1793: -- if the above process is success, delete all ancestrys
1794: If (x_return_status = OKC_API.G_RET_STS_SUCCESS) Then
1795: delete_ancestry(
1796: p_api_version => p_api_version,
1797: p_init_msg_list => p_init_msg_list,
1798: x_return_status => x_return_status,

Line 1805: OKC_API.SET_MESSAGE(p_app_name => g_app_name,

1801: p_cle_id => p_clev_rec.id);
1802: End If;
1803:
1804: Else
1805: OKC_API.SET_MESSAGE(p_app_name => g_app_name,
1806: p_msg_name => g_no_parent_record,
1807: p_token1 => g_child_table_token,
1808: p_token1_value => 'OKC_K_ITEMS_V',
1809: p_token2 => g_parent_table_token,

Line 1812: x_return_status := OKC_API.G_RET_STS_ERROR;

1808: p_token1_value => 'OKC_K_ITEMS_V',
1809: p_token2 => g_parent_table_token,
1810: p_token2_value => 'OKC_K_LINES_V');
1811: -- notify caller of an error
1812: x_return_status := OKC_API.G_RET_STS_ERROR;
1813: End If;
1814: Else
1815: OKC_API.SET_MESSAGE(p_app_name => g_app_name,
1816: p_msg_name => g_no_parent_record,

Line 1815: OKC_API.SET_MESSAGE(p_app_name => g_app_name,

1811: -- notify caller of an error
1812: x_return_status := OKC_API.G_RET_STS_ERROR;
1813: End If;
1814: Else
1815: OKC_API.SET_MESSAGE(p_app_name => g_app_name,
1816: p_msg_name => g_no_parent_record,
1817: p_token1 => g_child_table_token,
1818: p_token1_value => 'OKC_K_LINES_V',
1819: p_token2 => g_parent_table_token,

Line 1822: x_return_status := OKC_API.G_RET_STS_ERROR;

1818: p_token1_value => 'OKC_K_LINES_V',
1819: p_token2 => g_parent_table_token,
1820: p_token2_value => 'OKC_K_LINES_V');
1821: -- notify caller of an error
1822: x_return_status := OKC_API.G_RET_STS_ERROR;
1823: End If;
1824:
1825: -- Delete relationships with line and other objects
1826: If (x_return_status = OKC_API.G_RET_STS_SUCCESS) Then

Line 1826: If (x_return_status = OKC_API.G_RET_STS_SUCCESS) Then

1822: x_return_status := OKC_API.G_RET_STS_ERROR;
1823: End If;
1824:
1825: -- Delete relationships with line and other objects
1826: If (x_return_status = OKC_API.G_RET_STS_SUCCESS) Then
1827: For c In l_crjv_csr
1828: Loop
1829: l_crjv_rec.id := c.id;
1830: l_crjv_rec.object_version_number := c.object_version_number;

Line 1844: If (x_return_status = OKC_API.G_RET_STS_SUCCESS) Then

1840: End Loop;
1841: End If;
1842:
1843: -- Delete sales credits
1844: If (x_return_status = OKC_API.G_RET_STS_SUCCESS) Then
1845: For c In l_scrv_csr
1846: Loop
1847: l_scrv_rec.id := c.id;
1848: l_scrv_rec.object_version_number := c.object_version_number;

Line 1864: If (x_return_status = OKC_API.G_RET_STS_SUCCESS) Then

1860: End If;
1861:
1862:
1863: -- Delete price hold line breaks
1864: If (x_return_status = OKC_API.G_RET_STS_SUCCESS) Then
1865:
1866: /**********************************************
1867: don't need to do this for delete
1868: --added for price hold top lines

Line 1911: If (x_return_status = OKC_API.G_RET_STS_SUCCESS) Then

1907: End If;
1908:
1909:
1910: -- Delete all contract governances information at the line level
1911: If (x_return_status = OKC_API.G_RET_STS_SUCCESS) Then
1912: --(note: we do not have to write code to delete goverances in delete_contract_header because
1913: --that is already being done in okc_delete_contract_pvt.delete_contract where the delete is done
1914: --on the basis of dnz_chr_id so lines are deleted there as well)
1915:

Line 1942: If (x_return_status = OKC_API.G_RET_STS_SUCCESS) Then

1938: fetch l_cvm_csr into l_major_version;
1939: close l_cvm_csr;
1940:
1941: -- Delete any attachments assiciated with this line
1942: If (x_return_status = OKC_API.G_RET_STS_SUCCESS) Then
1943: If (fnd_attachment_util_pkg.get_atchmt_exists (
1944: l_entity_name => 'OKC_K_LINES_B',
1945: l_pkey1 => p_clev_rec.id,
1946: l_pkey2 => l_major_version) = 'Y')

Line 1963: If (x_return_status = OKC_API.G_RET_STS_SUCCESS) Then

1959: End If;
1960: End If;
1961:
1962: -- Update minor version
1963: If (x_return_status = OKC_API.G_RET_STS_SUCCESS) Then
1964: x_return_status := Update_Minor_Version(l_chr_id);
1965: End If;
1966: exception
1967: when G_NO_UPDATE_ALLOWED_EXCEPTION then

Line 1968: OKC_API.SET_MESSAGE(p_app_name => g_app_name,

1964: x_return_status := Update_Minor_Version(l_chr_id);
1965: End If;
1966: exception
1967: when G_NO_UPDATE_ALLOWED_EXCEPTION then
1968: OKC_API.SET_MESSAGE(p_app_name => g_app_name,
1969: p_msg_name => g_no_update_allowed,
1970: p_token1 => 'VALUE1',
1971: p_token1_value => 'Contract Lines');
1972:

Line 1974: x_return_status := OKC_API.G_RET_STS_ERROR;

1970: p_token1 => 'VALUE1',
1971: p_token1_value => 'Contract Lines');
1972:
1973: -- notify caller of an error
1974: x_return_status := OKC_API.G_RET_STS_ERROR;
1975: when OTHERS then
1976: -- store SQL error message on message stack
1977: OKC_API.SET_MESSAGE(p_app_name => g_app_name,
1978: p_msg_name => g_unexpected_error,

Line 1977: OKC_API.SET_MESSAGE(p_app_name => g_app_name,

1973: -- notify caller of an error
1974: x_return_status := OKC_API.G_RET_STS_ERROR;
1975: when OTHERS then
1976: -- store SQL error message on message stack
1977: OKC_API.SET_MESSAGE(p_app_name => g_app_name,
1978: p_msg_name => g_unexpected_error,
1979: p_token1 => g_sqlcode_token,
1980: p_token1_value => sqlcode,
1981: p_token2 => g_sqlerrm_token,

Line 1985: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

1981: p_token2 => g_sqlerrm_token,
1982: p_token2_value => sqlerrm);
1983:
1984: -- notify caller of an UNEXPETED error
1985: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
1986: END delete_contract_line;
1987:
1988: PROCEDURE delete_contract_line(
1989: p_api_version IN NUMBER,

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

2119: ---------------------------------------------------------------------------
2120: PROCEDURE Validate_Line_id(
2121: p_line_id IN NUMBER,
2122: x_return_status OUT NOCOPY VARCHAR2) IS
2123: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2124: l_Count NUMBER;
2125: CURSOR Cur_Line(P_Line_Id IN NUMBER) IS
2126: SELECT COUNT(*) FROM OKC_K_LINES_B
2127: WHERE id=P_Line_Id;

Line 2129: IF P_Line_id = OKC_API.G_MISS_NUM OR

2125: CURSOR Cur_Line(P_Line_Id IN NUMBER) IS
2126: SELECT COUNT(*) FROM OKC_K_LINES_B
2127: WHERE id=P_Line_Id;
2128: BEGIN
2129: IF P_Line_id = OKC_API.G_MISS_NUM OR
2130: P_Line_Id IS NULL
2131: THEN
2132: OKC_API.set_message(G_APP_NAME, G_REQUIRED_VALUE,G_COL_NAME_TOKEN,'P_Line_Id');
2133:

Line 2132: OKC_API.set_message(G_APP_NAME, G_REQUIRED_VALUE,G_COL_NAME_TOKEN,'P_Line_Id');

2128: BEGIN
2129: IF P_Line_id = OKC_API.G_MISS_NUM OR
2130: P_Line_Id IS NULL
2131: THEN
2132: OKC_API.set_message(G_APP_NAME, G_REQUIRED_VALUE,G_COL_NAME_TOKEN,'P_Line_Id');
2133:
2134: l_return_status := OKC_API.G_RET_STS_ERROR;
2135: END IF;
2136:

Line 2134: l_return_status := OKC_API.G_RET_STS_ERROR;

2130: P_Line_Id IS NULL
2131: THEN
2132: OKC_API.set_message(G_APP_NAME, G_REQUIRED_VALUE,G_COL_NAME_TOKEN,'P_Line_Id');
2133:
2134: l_return_status := OKC_API.G_RET_STS_ERROR;
2135: END IF;
2136:
2137: OPEN Cur_Line(P_LIne_Id);
2138: FETCH Cur_Line INTO l_Count;

Line 2142: OKC_API.set_message(G_APP_NAME, G_INVALID_VALUE,G_COL_NAME_TOKEN,'P_Line_Id');

2138: FETCH Cur_Line INTO l_Count;
2139: CLOSE Cur_Line;
2140: IF NOT l_Count = 1
2141: THEN
2142: OKC_API.set_message(G_APP_NAME, G_INVALID_VALUE,G_COL_NAME_TOKEN,'P_Line_Id');
2143:
2144: l_return_status := OKC_API.G_RET_STS_ERROR;
2145: END IF;
2146: x_return_status := l_return_status;

Line 2144: l_return_status := OKC_API.G_RET_STS_ERROR;

2140: IF NOT l_Count = 1
2141: THEN
2142: OKC_API.set_message(G_APP_NAME, G_INVALID_VALUE,G_COL_NAME_TOKEN,'P_Line_Id');
2143:
2144: l_return_status := OKC_API.G_RET_STS_ERROR;
2145: END IF;
2146: x_return_status := l_return_status;
2147: EXCEPTION
2148: WHEN OTHERS THEN

Line 2150: OKC_API.set_message(G_APP_NAME,

2146: x_return_status := l_return_status;
2147: EXCEPTION
2148: WHEN OTHERS THEN
2149: -- store SQL error message on message stack for caller
2150: OKC_API.set_message(G_APP_NAME,
2151: G_UNEXPECTED_ERROR,
2152: G_SQLCODE_TOKEN,
2153: SQLCODE,
2154: G_SQLERRM_TOKEN,

Line 2157: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

2153: SQLCODE,
2154: G_SQLERRM_TOKEN,
2155: SQLERRM);
2156: -- notify caller of an UNEXPECTED error
2157: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
2158: END Validate_Line_id;
2159: BEGIN
2160: x_return_status:=OKC_API.G_RET_STS_SUCCESS;
2161: Validate_Line_id(p_line_id,l_return_status);

Line 2160: x_return_status:=OKC_API.G_RET_STS_SUCCESS;

2156: -- notify caller of an UNEXPECTED error
2157: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
2158: END Validate_Line_id;
2159: BEGIN
2160: x_return_status:=OKC_API.G_RET_STS_SUCCESS;
2161: Validate_Line_id(p_line_id,l_return_status);
2162: IF NOT l_Return_Status ='S'
2163: THEN RETURN;
2164: END IF;

Line 2264: if not (l_return_status = OKC_API.G_RET_STS_SUCCESS)

2260: x_msg_count => l_msg_count,
2261: x_msg_data => l_msg_data,
2262: p_crjv_tbl => l_crjv_tbl_in);
2263:
2264: if not (l_return_status = OKC_API.G_RET_STS_SUCCESS)
2265: then
2266: return;
2267: end if;
2268: END IF;

Line 2279: if not (l_return_status = OKC_API.G_RET_STS_SUCCESS)

2275: x_msg_count => l_msg_count,
2276: x_msg_data => l_msg_data,
2277: p_ctcv_tbl => l_ctcv_tbl_in);
2278:
2279: if not (l_return_status = OKC_API.G_RET_STS_SUCCESS)
2280: then
2281: return;
2282: end if;
2283: END IF;

Line 2294: if not (l_return_status = OKC_API.G_RET_STS_SUCCESS)

2290: x_msg_count => l_msg_count,
2291: x_msg_data => l_msg_data,
2292: p_cplv_tbl => l_cplv_tbl_in);
2293:
2294: if not (l_return_status = OKC_API.G_RET_STS_SUCCESS)
2295: then
2296: return;
2297: end if;
2298: END IF;

Line 2321: If not (l_return_status = OKC_API.G_RET_STS_SUCCESS)

2317: x_msg_count => l_msg_count,
2318: x_msg_data => l_msg_data,
2319: p_rulv_tbl => l_rulv_tbl_in);
2320:
2321: If not (l_return_status = OKC_API.G_RET_STS_SUCCESS)
2322: THEN
2323:
2324: IF l_msg_count > 0
2325: THEN

Line 2348: if not (l_return_status = OKC_API.G_RET_STS_SUCCESS)

2344: x_msg_count => l_msg_count,
2345: x_msg_data => l_msg_data,
2346: p_rgpv_tbl => l_rgpv_tbl_in);
2347:
2348: if not (l_return_status = OKC_API.G_RET_STS_SUCCESS)
2349: then
2350: return;
2351: end if;
2352: END IF;

Line 2414: x_return_status := OKC_API.HANDLE_EXCEPTIONS

2410: WHEN e_Error THEN
2411: -- notify caller of an error as UNEXPETED error
2412: x_msg_count :=l_msg_count;
2413: x_msg_data:=l_msg_data;
2414: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2415: (
2416: l_api_name,
2417: 'Delete_Contract_Line',
2418: 'OKC_API.G_RET_STS_ERROR',

Line 2418: 'OKC_API.G_RET_STS_ERROR',

2414: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2415: (
2416: l_api_name,
2417: 'Delete_Contract_Line',
2418: 'OKC_API.G_RET_STS_ERROR',
2419: l_msg_count,
2420: l_msg_data,
2421: '_PVT'
2422: );

Line 2423: WHEN OKC_API.G_EXCEPTION_ERROR THEN

2419: l_msg_count,
2420: l_msg_data,
2421: '_PVT'
2422: );
2423: WHEN OKC_API.G_EXCEPTION_ERROR THEN
2424: x_msg_count :=l_msg_count;
2425: x_msg_data:=l_msg_data;
2426: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2427: (

Line 2426: x_return_status := OKC_API.HANDLE_EXCEPTIONS

2422: );
2423: WHEN OKC_API.G_EXCEPTION_ERROR THEN
2424: x_msg_count :=l_msg_count;
2425: x_msg_data:=l_msg_data;
2426: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2427: (
2428: l_api_name,
2429: 'Delete_Contract_Line',
2430: 'OKC_API.G_RET_STS_ERROR',

Line 2430: 'OKC_API.G_RET_STS_ERROR',

2426: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2427: (
2428: l_api_name,
2429: 'Delete_Contract_Line',
2430: 'OKC_API.G_RET_STS_ERROR',
2431: l_msg_count,
2432: l_msg_data,
2433: '_PVT'
2434: );

Line 2435: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

2431: l_msg_count,
2432: l_msg_data,
2433: '_PVT'
2434: );
2435: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
2436: x_msg_count :=l_msg_count;
2437: x_msg_data:=l_msg_data;
2438: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
2439: (

Line 2438: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

2434: );
2435: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
2436: x_msg_count :=l_msg_count;
2437: x_msg_data:=l_msg_data;
2438: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
2439: (
2440: l_api_name,
2441: 'Delete_Contract_Line',
2442: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 2442: 'OKC_API.G_RET_STS_UNEXP_ERROR',

2438: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
2439: (
2440: l_api_name,
2441: 'Delete_Contract_Line',
2442: 'OKC_API.G_RET_STS_UNEXP_ERROR',
2443: l_msg_count,
2444: l_msg_data,
2445: '_PVT'
2446: );

Line 2449: OKC_API.SET_MESSAGE(

2445: '_PVT'
2446: );
2447: WHEN OTHERS THEN
2448: x_msg_count :=l_msg_count;
2449: OKC_API.SET_MESSAGE(
2450: p_app_name => g_app_name,
2451: p_msg_name => g_unexpected_error,
2452: p_token1 => g_sqlcode_token,
2453: p_token1_value => sqlcode,

Line 2457: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

2453: p_token1_value => sqlcode,
2454: p_token2 => g_sqlerrm_token,
2455: p_token2_value => sqlerrm);
2456: -- notify caller of an error as UNEXPETED error
2457: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
2458:
2459: END delete_contract_line;
2460:
2461: PROCEDURE force_delete_contract_line(

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

2547: l_cplv_tbl_in okc_contract_party_pub.cplv_tbl_type;
2548: l_crjv_tbl_in okc_k_rel_objs_pub.crjv_tbl_type;
2549: l_api_version CONSTANT NUMBER := 1.0;
2550: l_init_msg_list CONSTANT VARCHAR2(1) := 'T';
2551: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2552: l_msg_count NUMBER;
2553: l_msg_data VARCHAR2(2000):=null;
2554: l_msg_index_out Number;
2555: l_api_name CONSTANT VARCHAR2(30) := 'Delete_Contract_Line';

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

2570: ---------------------------------------------------------------------------
2571: PROCEDURE Validate_Line_id(
2572: p_line_id IN NUMBER,
2573: x_return_status OUT NOCOPY VARCHAR2) IS
2574: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2575: l_Count NUMBER;
2576: CURSOR Cur_Line(P_Line_Id IN NUMBER) IS
2577: SELECT COUNT(*) FROM OKC_K_LINES_B
2578: WHERE id=P_Line_Id;

Line 2584: IF P_Line_id = OKC_API.G_MISS_NUM OR

2580:
2581: IF (l_debug = 'Y') THEN
2582: okc_debug.log('100: Validate_Line_id starts', 2);
2583: END IF;
2584: IF P_Line_id = OKC_API.G_MISS_NUM OR
2585: P_Line_Id IS NULL
2586: THEN
2587: OKC_API.set_message(G_APP_NAME, G_REQUIRED_VALUE,G_COL_NAME_TOKEN,'P_Line_Id');
2588:

Line 2587: OKC_API.set_message(G_APP_NAME, G_REQUIRED_VALUE,G_COL_NAME_TOKEN,'P_Line_Id');

2583: END IF;
2584: IF P_Line_id = OKC_API.G_MISS_NUM OR
2585: P_Line_Id IS NULL
2586: THEN
2587: OKC_API.set_message(G_APP_NAME, G_REQUIRED_VALUE,G_COL_NAME_TOKEN,'P_Line_Id');
2588:
2589: l_return_status := OKC_API.G_RET_STS_ERROR;
2590: END IF;
2591:

Line 2589: l_return_status := OKC_API.G_RET_STS_ERROR;

2585: P_Line_Id IS NULL
2586: THEN
2587: OKC_API.set_message(G_APP_NAME, G_REQUIRED_VALUE,G_COL_NAME_TOKEN,'P_Line_Id');
2588:
2589: l_return_status := OKC_API.G_RET_STS_ERROR;
2590: END IF;
2591:
2592: IF (l_debug = 'Y') THEN
2593: okc_debug.log('200: l_return_status = ' || l_return_status, 2);

Line 2601: OKC_API.set_message(G_APP_NAME, G_INVALID_VALUE,G_COL_NAME_TOKEN,'P_Line_Id');

2597: FETCH Cur_Line INTO l_Count;
2598: CLOSE Cur_Line;
2599: IF NOT l_Count = 1
2600: THEN
2601: OKC_API.set_message(G_APP_NAME, G_INVALID_VALUE,G_COL_NAME_TOKEN,'P_Line_Id');
2602:
2603: l_return_status := OKC_API.G_RET_STS_ERROR;
2604: END IF;
2605: x_return_status := l_return_status;

Line 2603: l_return_status := OKC_API.G_RET_STS_ERROR;

2599: IF NOT l_Count = 1
2600: THEN
2601: OKC_API.set_message(G_APP_NAME, G_INVALID_VALUE,G_COL_NAME_TOKEN,'P_Line_Id');
2602:
2603: l_return_status := OKC_API.G_RET_STS_ERROR;
2604: END IF;
2605: x_return_status := l_return_status;
2606: IF (l_debug = 'Y') THEN
2607: okc_debug.log('300: validate_line_id ends', 2);

Line 2612: OKC_API.set_message(G_APP_NAME,

2608: END IF;
2609: EXCEPTION
2610: WHEN OTHERS THEN
2611: -- store SQL error message on message stack for caller
2612: OKC_API.set_message(G_APP_NAME,
2613: G_UNEXPECTED_ERROR,
2614: G_SQLCODE_TOKEN,
2615: SQLCODE,
2616: G_SQLERRM_TOKEN,

Line 2619: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

2615: SQLCODE,
2616: G_SQLERRM_TOKEN,
2617: SQLERRM);
2618: -- notify caller of an UNEXPECTED error
2619: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
2620: IF (l_debug = 'Y') THEN
2621: okc_debug.log('300: WHEN OTHERS EXCEPTION', 2);
2622: END IF;
2623: END Validate_Line_id;

Line 2702: IF x_return_status <> OKC_API.G_RET_STS_SUCCESS THEN

2698: x_msg_count => x_msg_count,
2699: x_msg_data => x_msg_data,
2700: p_ctiv_tbl => l_ctiv_tbl);
2701:
2702: IF x_return_status <> OKC_API.G_RET_STS_SUCCESS THEN
2703: IF (l_debug = 'Y') THEN
2704: okc_debug.log('200: x_return_status = ' || x_return_status, 2);
2705: END IF;
2706: -- stop delete process

Line 2733: IF x_return_status <> OKC_API.G_RET_STS_SUCCESS THEN

2729: x_msg_count => x_msg_count,
2730: x_msg_data => x_msg_data,
2731: p_rilv_tbl => l_rilv_tbl);
2732:
2733: IF x_return_status <> OKC_API.G_RET_STS_SUCCESS THEN
2734: IF (l_debug = 'Y') THEN
2735: okc_debug.log('300: x_return_status = ' || x_return_status, 2);
2736: END IF;
2737: -- stop delete process

Line 2776: IF x_return_status <> OKC_API.G_RET_STS_SUCCESS THEN

2772: x_return_status => x_return_status,
2773: x_msg_count => x_msg_count,
2774: x_msg_data => x_msg_data,
2775: p_tve_id => l_col_vals(i).col_value);
2776: IF x_return_status <> OKC_API.G_RET_STS_SUCCESS THEN
2777: IF (l_debug = 'Y') THEN
2778: okc_debug.log('700: x_return_status = ' || x_return_status, 2);
2779: END IF;
2780: -- stop delete process

Line 2813: OKC_API.SET_MESSAGE(

2809: WHEN G_EXCEPTION_CANNOT_DELETE THEN
2810:
2811:
2812: -- store SQL error message on message stack
2813: OKC_API.SET_MESSAGE(
2814: p_app_name => G_APP_NAME,
2815: p_msg_name => G_CANNOT_DELETE_MASTER);
2816: -- notify caller of an error
2817: x_return_status := OKC_API.G_RET_STS_ERROR;

Line 2817: x_return_status := OKC_API.G_RET_STS_ERROR;

2813: OKC_API.SET_MESSAGE(
2814: p_app_name => G_APP_NAME,
2815: p_msg_name => G_CANNOT_DELETE_MASTER);
2816: -- notify caller of an error
2817: x_return_status := OKC_API.G_RET_STS_ERROR;
2818:
2819: */
2820: WHEN OTHERS THEN
2821: -- store SQL error message on message stack

Line 2822: OKC_API.SET_MESSAGE(

2818:
2819: */
2820: WHEN OTHERS THEN
2821: -- store SQL error message on message stack
2822: OKC_API.SET_MESSAGE(
2823: p_app_name => G_APP_NAME,
2824: p_msg_name => G_UNEXPECTED_ERROR,
2825: p_token1 => G_SQLCODE_TOKEN,
2826: p_token1_value => SQLCODE,

Line 2830: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

2826: p_token1_value => SQLCODE,
2827: p_token2 => G_SQLERRM_TOKEN,
2828: p_token2_value => SQLERRM);
2829: -- notify caller of an error as UNEXPETED error
2830: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
2831: -- verify that cursor was closed
2832: IF l_ctiv_csr%ISOPEN THEN
2833: CLOSE l_ctiv_csr;
2834: END IF;

Line 2848: x_return_status:=OKC_API.G_RET_STS_SUCCESS;

2844: IF (l_debug = 'Y') THEN
2845: okc_debug.log('100: starting force delete', 2);
2846: okc_debug.log('200: cle_id=' || to_char(p_line_id),2);
2847: END IF;
2848: x_return_status:=OKC_API.G_RET_STS_SUCCESS;
2849: Validate_Line_id(p_line_id,l_return_status);
2850: IF NOT l_Return_Status ='S'
2851: THEN
2852: x_return_status := l_return_status;

Line 2964: if not (l_return_status = OKC_API.G_RET_STS_SUCCESS)

2960: IF (l_debug = 'Y') THEN
2961: okc_debug.log('500: l_return_status = ' || l_return_status, 2);
2962: END IF;
2963:
2964: if not (l_return_status = OKC_API.G_RET_STS_SUCCESS)
2965: then
2966: x_return_status := l_return_status;
2967: return;
2968: end if;

Line 2989: if not (l_return_status = OKC_API.G_RET_STS_SUCCESS)

2985: IF (l_debug = 'Y') THEN
2986: okc_debug.log('700: l_return_status = ' || l_return_status, 2);
2987: END IF;
2988:
2989: if not (l_return_status = OKC_API.G_RET_STS_SUCCESS)
2990: then
2991: x_return_status := l_return_status;
2992: return;
2993: end if;

Line 3013: if not (l_return_status = OKC_API.G_RET_STS_SUCCESS)

3009:
3010: IF (l_debug = 'Y') THEN
3011: okc_debug.log('900: l_return_status = ' || l_return_status, 2);
3012: END IF;
3013: if not (l_return_status = OKC_API.G_RET_STS_SUCCESS)
3014: then
3015: x_return_status := l_return_status;
3016: return;
3017: end if;

Line 3042: if not (l_return_status = OKC_API.G_RET_STS_SUCCESS)

3038: okc_debug.log('1050: l_return_status = ' || l_return_status, 2);
3039: okc_debug.log('1100: calling OKC_CONTRACT_PARTY_PUB.Delete_Contact', 2);
3040: END IF;
3041:
3042: if not (l_return_status = OKC_API.G_RET_STS_SUCCESS)
3043: THEN
3044: /*
3045: IF l_msg_count > 0
3046: THEN

Line 3084: if not (l_return_status = OKC_API.G_RET_STS_SUCCESS)

3080: IF (l_debug = 'Y') THEN
3081: okc_debug.log('1300: l_return_status = ' || l_return_status, 2);
3082: END IF;
3083:
3084: if not (l_return_status = OKC_API.G_RET_STS_SUCCESS)
3085: then
3086: x_return_status := l_return_status;
3087: return;
3088: end if;

Line 3144: If (l_return_status = OKC_API.G_RET_STS_SUCCESS) Then

3140: okc_debug.log('1500: l_return_status = ' || l_return_status, 2);
3141: END IF;
3142:
3143: -- if the above process is success, delete all ancestrys
3144: If (l_return_status = OKC_API.G_RET_STS_SUCCESS) Then
3145:
3146: IF (l_debug = 'Y') THEN
3147: okc_debug.log('1600: calling delete_ancestry', 2);
3148: END IF;

Line 3163: If (l_return_status <> OKC_API.G_RET_STS_SUCCESS) Then

3159: IF (l_debug = 'Y') THEN
3160: okc_debug.log('1700: l_return_status = ' || l_return_status, 2);
3161: END IF;
3162:
3163: If (l_return_status <> OKC_API.G_RET_STS_SUCCESS) Then
3164: x_return_status := l_return_status;
3165: exit;
3166: End If;
3167: END LOOP;

Line 3199: x_return_status := OKC_API.HANDLE_EXCEPTIONS

3195: END IF;
3196: -- notify caller of an error as UNEXPETED error
3197: x_msg_count :=l_msg_count;
3198: x_msg_data:=l_msg_data;
3199: x_return_status := OKC_API.HANDLE_EXCEPTIONS
3200: (
3201: l_api_name,
3202: 'Delete_Contract_Line',
3203: 'OKC_API.G_RET_STS_ERROR',

Line 3203: 'OKC_API.G_RET_STS_ERROR',

3199: x_return_status := OKC_API.HANDLE_EXCEPTIONS
3200: (
3201: l_api_name,
3202: 'Delete_Contract_Line',
3203: 'OKC_API.G_RET_STS_ERROR',
3204: l_msg_count,
3205: l_msg_data,
3206: '_PVT'
3207: );

Line 3208: WHEN OKC_API.G_EXCEPTION_ERROR THEN

3204: l_msg_count,
3205: l_msg_data,
3206: '_PVT'
3207: );
3208: WHEN OKC_API.G_EXCEPTION_ERROR THEN
3209: IF (l_debug = 'Y') THEN
3210: okc_debug.log('1900: WHEN OKC_API.G_EXCEPTION_ERROR EXCEPTION', 2);
3211: END IF;
3212: x_msg_count :=l_msg_count;

Line 3210: okc_debug.log('1900: WHEN OKC_API.G_EXCEPTION_ERROR EXCEPTION', 2);

3206: '_PVT'
3207: );
3208: WHEN OKC_API.G_EXCEPTION_ERROR THEN
3209: IF (l_debug = 'Y') THEN
3210: okc_debug.log('1900: WHEN OKC_API.G_EXCEPTION_ERROR EXCEPTION', 2);
3211: END IF;
3212: x_msg_count :=l_msg_count;
3213: x_msg_data:=l_msg_data;
3214: x_return_status := OKC_API.HANDLE_EXCEPTIONS

Line 3214: x_return_status := OKC_API.HANDLE_EXCEPTIONS

3210: okc_debug.log('1900: WHEN OKC_API.G_EXCEPTION_ERROR EXCEPTION', 2);
3211: END IF;
3212: x_msg_count :=l_msg_count;
3213: x_msg_data:=l_msg_data;
3214: x_return_status := OKC_API.HANDLE_EXCEPTIONS
3215: (
3216: l_api_name,
3217: 'Delete_Contract_Line',
3218: 'OKC_API.G_RET_STS_ERROR',

Line 3218: 'OKC_API.G_RET_STS_ERROR',

3214: x_return_status := OKC_API.HANDLE_EXCEPTIONS
3215: (
3216: l_api_name,
3217: 'Delete_Contract_Line',
3218: 'OKC_API.G_RET_STS_ERROR',
3219: l_msg_count,
3220: l_msg_data,
3221: '_PVT'
3222: );

Line 3223: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

3219: l_msg_count,
3220: l_msg_data,
3221: '_PVT'
3222: );
3223: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
3224: IF (l_debug = 'Y') THEN
3225: okc_debug.log('2000: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR EXCEPTION', 2);
3226: END IF;
3227: x_msg_count :=l_msg_count;

Line 3225: okc_debug.log('2000: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR EXCEPTION', 2);

3221: '_PVT'
3222: );
3223: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
3224: IF (l_debug = 'Y') THEN
3225: okc_debug.log('2000: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR EXCEPTION', 2);
3226: END IF;
3227: x_msg_count :=l_msg_count;
3228: x_msg_data:=l_msg_data;
3229: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

Line 3229: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

3225: okc_debug.log('2000: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR EXCEPTION', 2);
3226: END IF;
3227: x_msg_count :=l_msg_count;
3228: x_msg_data:=l_msg_data;
3229: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
3230: (
3231: l_api_name,
3232: 'Force_Delete_K_Line',
3233: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 3233: 'OKC_API.G_RET_STS_UNEXP_ERROR',

3229: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
3230: (
3231: l_api_name,
3232: 'Force_Delete_K_Line',
3233: 'OKC_API.G_RET_STS_UNEXP_ERROR',
3234: l_msg_count,
3235: l_msg_data,
3236: '_PVT'
3237: );

Line 3243: OKC_API.SET_MESSAGE(

3239: IF (l_debug = 'Y') THEN
3240: okc_debug.log('2100: WHEN OTHERS EXCEPTION', 2);
3241: END IF;
3242: x_msg_count :=l_msg_count;
3243: OKC_API.SET_MESSAGE(
3244: p_app_name => g_app_name,
3245: p_msg_name => g_unexpected_error,
3246: p_token1 => g_sqlcode_token,
3247: p_token1_value => sqlcode,

Line 3251: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

3247: p_token1_value => sqlcode,
3248: p_token2 => g_sqlerrm_token,
3249: p_token2_value => sqlerrm);
3250: -- notify caller of an error as UNEXPETED error
3251: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
3252:
3253: END force_delete_contract_line;
3254:
3255: PROCEDURE lock_contract_line(

Line 3347: If (x_return_status = OKC_API.G_RET_STS_SUCCESS) Then

3343: p_gvev_rec => p_gvev_rec,
3344: x_gvev_rec => x_gvev_rec);
3345:
3346: -- Update minor version
3347: If (x_return_status = OKC_API.G_RET_STS_SUCCESS) Then
3348: x_return_status := Update_Minor_Version(x_gvev_rec.dnz_chr_id);
3349: End If;
3350: END create_governance;
3351:

Line 3392: If (x_return_status = OKC_API.G_RET_STS_SUCCESS) Then

3388: p_gvev_rec => p_gvev_rec,
3389: x_gvev_rec => x_gvev_rec);
3390:
3391: -- Update minor version
3392: If (x_return_status = OKC_API.G_RET_STS_SUCCESS) Then
3393: x_return_status := Update_Minor_Version(x_gvev_rec.dnz_chr_id);
3394: End If;
3395: END update_governance;
3396:

Line 3444: If (x_return_status = OKC_API.G_RET_STS_SUCCESS) Then

3440: x_msg_data => x_msg_data,
3441: p_gvev_rec => p_gvev_rec);
3442:
3443: -- Update minor version
3444: If (x_return_status = OKC_API.G_RET_STS_SUCCESS) Then
3445: x_return_status := Update_Minor_Version(l_chr_id);
3446: End If;
3447: END delete_governance;
3448:

Line 3559: If (x_return_status = OKC_API.G_RET_STS_SUCCESS) Then

3555: p_cpsv_rec => p_cpsv_rec,
3556: x_cpsv_rec => x_cpsv_rec);
3557:
3558: -- Update minor version
3559: If (x_return_status = OKC_API.G_RET_STS_SUCCESS) Then
3560: If (p_cpsv_rec.chr_id is not null and
3561: p_cpsv_rec.chr_id <> OKC_API.G_MISS_NUM) Then
3562: x_return_status := Update_Minor_Version(p_cpsv_rec.chr_id);
3563: End If;

Line 3561: p_cpsv_rec.chr_id <> OKC_API.G_MISS_NUM) Then

3557:
3558: -- Update minor version
3559: If (x_return_status = OKC_API.G_RET_STS_SUCCESS) Then
3560: If (p_cpsv_rec.chr_id is not null and
3561: p_cpsv_rec.chr_id <> OKC_API.G_MISS_NUM) Then
3562: x_return_status := Update_Minor_Version(p_cpsv_rec.chr_id);
3563: End If;
3564: End If;
3565: END create_contract_process;

Line 3614: If (x_return_status = OKC_API.G_RET_STS_SUCCESS) Then

3610: p_cpsv_rec => p_cpsv_rec,
3611: x_cpsv_rec => x_cpsv_rec);
3612:
3613: -- Update minor version
3614: If (x_return_status = OKC_API.G_RET_STS_SUCCESS) Then
3615: If (p_cpsv_rec.chr_id is not null and
3616: p_cpsv_rec.chr_id <> OKC_API.G_MISS_NUM) Then
3617: x_return_status := Update_Minor_Version(p_cpsv_rec.chr_id);
3618: End If;

Line 3616: p_cpsv_rec.chr_id <> OKC_API.G_MISS_NUM) Then

3612:
3613: -- Update minor version
3614: If (x_return_status = OKC_API.G_RET_STS_SUCCESS) Then
3615: If (p_cpsv_rec.chr_id is not null and
3616: p_cpsv_rec.chr_id <> OKC_API.G_MISS_NUM) Then
3617: x_return_status := Update_Minor_Version(p_cpsv_rec.chr_id);
3618: End If;
3619: End If;
3620: exception

Line 3622: OKC_API.SET_MESSAGE(p_app_name => g_app_name,

3618: End If;
3619: End If;
3620: exception
3621: when G_NO_UPDATE_ALLOWED_EXCEPTION then
3622: OKC_API.SET_MESSAGE(p_app_name => g_app_name,
3623: p_msg_name => g_no_update_allowed,
3624: p_token1 => 'VALUE1',
3625: p_token1_value => 'Contract Processes');
3626:

Line 3628: x_return_status := OKC_API.G_RET_STS_ERROR;

3624: p_token1 => 'VALUE1',
3625: p_token1_value => 'Contract Processes');
3626:
3627: -- notify caller of an error
3628: x_return_status := OKC_API.G_RET_STS_ERROR;
3629: when OTHERS then
3630: -- store SQL error message on message stack
3631: OKC_API.SET_MESSAGE(p_app_name => g_app_name,
3632: p_msg_name => g_unexpected_error,

Line 3631: OKC_API.SET_MESSAGE(p_app_name => g_app_name,

3627: -- notify caller of an error
3628: x_return_status := OKC_API.G_RET_STS_ERROR;
3629: when OTHERS then
3630: -- store SQL error message on message stack
3631: OKC_API.SET_MESSAGE(p_app_name => g_app_name,
3632: p_msg_name => g_unexpected_error,
3633: p_token1 => g_sqlcode_token,
3634: p_token1_value => sqlcode,
3635: p_token2 => g_sqlerrm_token,

Line 3639: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

3635: p_token2 => g_sqlerrm_token,
3636: p_token2_value => sqlerrm);
3637:
3638: -- notify caller of an UNEXPETED error
3639: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
3640: END update_contract_process;
3641:
3642: PROCEDURE update_contract_process(
3643: p_api_version IN NUMBER,

Line 3689: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

3685: fetch l_cpsv_csr into l_chr_id;
3686: l_not_found := l_cpsv_csr%NOTFOUND;
3687: close l_cpsv_csr;
3688: If (l_not_found) Then
3689: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
3690: -- store SQL error message on message stack
3691: OKC_API.SET_MESSAGE(
3692: p_app_name => g_app_name,
3693: p_msg_name => g_unexpected_error,

Line 3691: OKC_API.SET_MESSAGE(

3687: close l_cpsv_csr;
3688: If (l_not_found) Then
3689: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
3690: -- store SQL error message on message stack
3691: OKC_API.SET_MESSAGE(
3692: p_app_name => g_app_name,
3693: p_msg_name => g_unexpected_error,
3694: p_token1 => g_sqlcode_token,
3695: p_token1_value => sqlcode,

Line 3709: If (x_return_status = OKC_API.G_RET_STS_SUCCESS and

3705: x_msg_data => x_msg_data,
3706: p_cpsv_rec => p_cpsv_rec);
3707:
3708: -- Update minor version
3709: If (x_return_status = OKC_API.G_RET_STS_SUCCESS and
3710: l_chr_id is not null)
3711: Then
3712: x_return_status := Update_Minor_Version(l_chr_id);
3713: End If;

Line 3716: OKC_API.SET_MESSAGE(p_app_name => g_app_name,

3712: x_return_status := Update_Minor_Version(l_chr_id);
3713: End If;
3714: exception
3715: when G_NO_UPDATE_ALLOWED_EXCEPTION then
3716: OKC_API.SET_MESSAGE(p_app_name => g_app_name,
3717: p_msg_name => g_no_update_allowed,
3718: p_token1 => 'VALUE1',
3719: p_token1_value => 'Contract Processes');
3720:

Line 3722: x_return_status := OKC_API.G_RET_STS_ERROR;

3718: p_token1 => 'VALUE1',
3719: p_token1_value => 'Contract Processes');
3720:
3721: -- notify caller of an error
3722: x_return_status := OKC_API.G_RET_STS_ERROR;
3723: when OTHERS then
3724: -- store SQL error message on message stack
3725: OKC_API.SET_MESSAGE(p_app_name => g_app_name,
3726: p_msg_name => g_unexpected_error,

Line 3725: OKC_API.SET_MESSAGE(p_app_name => g_app_name,

3721: -- notify caller of an error
3722: x_return_status := OKC_API.G_RET_STS_ERROR;
3723: when OTHERS then
3724: -- store SQL error message on message stack
3725: OKC_API.SET_MESSAGE(p_app_name => g_app_name,
3726: p_msg_name => g_unexpected_error,
3727: p_token1 => g_sqlcode_token,
3728: p_token1_value => sqlcode,
3729: p_token2 => g_sqlerrm_token,

Line 3733: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

3729: p_token2 => g_sqlerrm_token,
3730: p_token2_value => sqlerrm);
3731:
3732: -- notify caller of an UNEXPETED error
3733: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
3734: END delete_contract_process;
3735:
3736: PROCEDURE delete_contract_process(
3737: p_api_version IN NUMBER,

Line 3846: If (x_return_status = OKC_API.G_RET_STS_SUCCESS) Then

3842: p_cacv_rec => p_cacv_rec,
3843: x_cacv_rec => x_cacv_rec);
3844:
3845: -- Update minor version
3846: If (x_return_status = OKC_API.G_RET_STS_SUCCESS) Then
3847: x_return_status := Update_Minor_Version(x_cacv_rec.chr_id);
3848: End If;
3849: END create_contract_access;
3850:

Line 3891: If (x_return_status = OKC_API.G_RET_STS_SUCCESS) Then

3887: p_cacv_rec => p_cacv_rec,
3888: x_cacv_rec => x_cacv_rec);
3889:
3890: -- Update minor version
3891: If (x_return_status = OKC_API.G_RET_STS_SUCCESS) Then
3892: x_return_status := Update_Minor_Version(x_cacv_rec.chr_id);
3893: End If;
3894: END update_contract_access;
3895:

Line 3937: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

3933: l_not_found := l_cacv_csr%NOTFOUND;
3934: Close l_cacv_csr;
3935:
3936: If (l_not_found) Then
3937: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
3938: -- store SQL error message on message stack
3939: OKC_API.SET_MESSAGE(
3940: p_app_name => g_app_name,
3941: p_msg_name => g_unexpected_error,

Line 3939: OKC_API.SET_MESSAGE(

3935:
3936: If (l_not_found) Then
3937: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
3938: -- store SQL error message on message stack
3939: OKC_API.SET_MESSAGE(
3940: p_app_name => g_app_name,
3941: p_msg_name => g_unexpected_error,
3942: p_token1 => g_sqlcode_token,
3943: p_token1_value => sqlcode,

Line 3958: If (x_return_status = OKC_API.G_RET_STS_SUCCESS) Then

3954: x_msg_data => x_msg_data,
3955: p_cacv_rec => p_cacv_rec);
3956:
3957: -- Update minor version
3958: If (x_return_status = OKC_API.G_RET_STS_SUCCESS) Then
3959: x_return_status := Update_Minor_Version(l_chr_id);
3960: End If;
3961: END delete_contract_access;
3962:

Line 4102: x_return_status := OKC_API.G_RET_STS_SUCCESS;

4098: AND cpsv.last_update_date = (SELECT MAX(last_update_date)
4099: FROM okc_k_processes
4100: WHERE chr_id = l_chr_id);
4101: BEGIN
4102: x_return_status := OKC_API.G_RET_STS_SUCCESS;
4103: -- get id from header table
4104: If (p_contract_number_modifier is not null) Then
4105: Open l_chrv_csr;
4106: Fetch l_chrv_csr into l_chr_id;

Line 4129: x_return_status := OKC_API.G_RET_STS_ERROR;

4125: x_wf_process_name,
4126: x_package_name,
4127: x_procedure_name;
4128: If l_pdfv_csr%NOTFOUND Then
4129: x_return_status := OKC_API.G_RET_STS_ERROR;
4130: End If;
4131: Close l_pdfv_csr;
4132: Else
4133: x_usage := NULL;

Line 4154: -- OKC_API.SET_MESSAGE(p_app_name => g_app_name,

4150: x_wf_process_name := NULL;
4151: x_package_name := NULL;
4152: x_procedure_name := NULL;
4153:
4154: -- OKC_API.SET_MESSAGE(p_app_name => g_app_name,
4155: -- p_msg_name => 'NO_CONTRACT_FOUND');
4156: -- x_return_status := OKC_API.G_RET_STS_ERROR;
4157: when OTHERS then
4158: -- store SQL error message on message stack

Line 4156: -- x_return_status := OKC_API.G_RET_STS_ERROR;

4152: x_procedure_name := NULL;
4153:
4154: -- OKC_API.SET_MESSAGE(p_app_name => g_app_name,
4155: -- p_msg_name => 'NO_CONTRACT_FOUND');
4156: -- x_return_status := OKC_API.G_RET_STS_ERROR;
4157: when OTHERS then
4158: -- store SQL error message on message stack
4159: OKC_API.SET_MESSAGE(p_app_name => g_app_name,
4160: p_msg_name => g_unexpected_error,

Line 4159: OKC_API.SET_MESSAGE(p_app_name => g_app_name,

4155: -- p_msg_name => 'NO_CONTRACT_FOUND');
4156: -- x_return_status := OKC_API.G_RET_STS_ERROR;
4157: when OTHERS then
4158: -- store SQL error message on message stack
4159: OKC_API.SET_MESSAGE(p_app_name => g_app_name,
4160: p_msg_name => g_unexpected_error,
4161: p_token1 => g_sqlcode_token,
4162: p_token1_value => sqlcode,
4163: p_token2 => g_sqlerrm_token,

Line 4167: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

4163: p_token2 => g_sqlerrm_token,
4164: p_token2_value => sqlerrm);
4165:
4166: -- notify caller of an UNEXPETED error
4167: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
4168: END Get_Active_Process;
4169:
4170: --
4171: -- function that checkes whether a contract is updateable or not

Line 4173: -- returns OKC_API.G_RET_STS_ERROR or OKC_API.G_RET_STS_UNEXP_ERROR

4169:
4170: --
4171: -- function that checkes whether a contract is updateable or not
4172: -- returns 'Y' if updateable, 'N' if not.
4173: -- returns OKC_API.G_RET_STS_ERROR or OKC_API.G_RET_STS_UNEXP_ERROR
4174: -- in case of error
4175: --
4176: FUNCTION Update_Allowed(p_chr_id IN NUMBER) RETURN VARCHAR2 Is
4177: l_sts_code OKC_ASSENTS.STS_CODE%TYPE;

Line 4205: l_return_value := OKC_API.G_RET_STS_UNEXP_ERROR;

4201: Close l_chrv_csr;
4202: Open l_astv_csr;
4203: Fetch l_astv_csr into l_return_value;
4204: If (l_return_value not in ('Y','N')) Then
4205: l_return_value := OKC_API.G_RET_STS_UNEXP_ERROR;
4206: End If;
4207: Close l_astv_csr;
4208: Else
4209: Close l_chrv_csr;

Line 4215: OKC_API.SET_MESSAGE(p_app_name => g_app_name,

4211: return l_return_value;
4212: Exception
4213: when OTHERS then
4214: -- store SQL error message on message stack
4215: OKC_API.SET_MESSAGE(p_app_name => g_app_name,
4216: p_msg_name => g_unexpected_error,
4217: p_token1 => g_sqlcode_token,
4218: p_token1_value => sqlcode,
4219: p_token2 => g_sqlerrm_token,

Line 4223: l_return_value := OKC_API.G_RET_STS_UNEXP_ERROR;

4219: p_token2 => g_sqlerrm_token,
4220: p_token2_value => sqlerrm);
4221:
4222: -- notify caller of an UNEXPETED error
4223: l_return_value := OKC_API.G_RET_STS_UNEXP_ERROR;
4224: END Update_Allowed;
4225:
4226: --------------------------------------------------------------------
4227: -- Procedure to clear/relink renewal links

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

4242: clean_relink_flag VARCHAR2)
4243:
4244: IS
4245: l_api_name VARCHAR2(30) := 'LINE_RENEWAL_LINKS';
4246: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
4247: l_active_yn VARCHAR2(1) := 'N';
4248: l_no_of_lines NUMBER;
4249: l_no_of_op_lines NUMBER;
4250:

Line 4295: x_return_status := OKC_API.G_RET_STS_SUCCESS;

4291: AND OBJECT_CHR_ID = p_object_chr_id)
4292: AND dnz_chr_id = p_object_chr_id;
4293:
4294: BEGIN
4295: x_return_status := OKC_API.G_RET_STS_SUCCESS;
4296: l_return_status := OKC_API.START_ACTIVITY
4297: (l_api_name, p_init_msg_list, '_PVT', x_return_status);
4298:
4299: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

Line 4296: l_return_status := OKC_API.START_ACTIVITY

4292: AND dnz_chr_id = p_object_chr_id;
4293:
4294: BEGIN
4295: x_return_status := OKC_API.G_RET_STS_SUCCESS;
4296: l_return_status := OKC_API.START_ACTIVITY
4297: (l_api_name, p_init_msg_list, '_PVT', x_return_status);
4298:
4299: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
4300: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

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

4295: x_return_status := OKC_API.G_RET_STS_SUCCESS;
4296: l_return_status := OKC_API.START_ACTIVITY
4297: (l_api_name, p_init_msg_list, '_PVT', x_return_status);
4298:
4299: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
4300: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
4301: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
4302: RAISE OKC_API.G_EXCEPTION_ERROR;
4303: END IF;

Line 4300: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

4296: l_return_status := OKC_API.START_ACTIVITY
4297: (l_api_name, p_init_msg_list, '_PVT', x_return_status);
4298:
4299: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
4300: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
4301: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
4302: RAISE OKC_API.G_EXCEPTION_ERROR;
4303: END IF;
4304:

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

4297: (l_api_name, p_init_msg_list, '_PVT', x_return_status);
4298:
4299: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
4300: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
4301: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
4302: RAISE OKC_API.G_EXCEPTION_ERROR;
4303: END IF;
4304:
4305: -- set flag to update

Line 4302: RAISE OKC_API.G_EXCEPTION_ERROR;

4298:
4299: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
4300: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
4301: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
4302: RAISE OKC_API.G_EXCEPTION_ERROR;
4303: END IF;
4304:
4305: -- set flag to update
4306: IF (NVL(clean_relink_flag,'CLEAN') = 'RELINK') Then

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

4427: FOR ole_rec IN ole_csr
4428: LOOP
4429: x_return_status := update_minor_version(ole_rec.object_chr_id);
4430:
4431: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
4432: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
4433: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
4434: raise OKC_API.G_EXCEPTION_ERROR;
4435: END IF;

Line 4432: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

4428: LOOP
4429: x_return_status := update_minor_version(ole_rec.object_chr_id);
4430:
4431: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
4432: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
4433: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
4434: raise OKC_API.G_EXCEPTION_ERROR;
4435: END IF;
4436: END LOOP;

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

4429: x_return_status := update_minor_version(ole_rec.object_chr_id);
4430:
4431: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
4432: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
4433: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
4434: raise OKC_API.G_EXCEPTION_ERROR;
4435: END IF;
4436: END LOOP;
4437:

Line 4434: raise OKC_API.G_EXCEPTION_ERROR;

4430:
4431: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
4432: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
4433: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
4434: raise OKC_API.G_EXCEPTION_ERROR;
4435: END IF;
4436: END LOOP;
4437:
4438: --- Added for Bug# 2606251 --- to increment version for a renewed contract(when staus is changed)

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

4438: --- Added for Bug# 2606251 --- to increment version for a renewed contract(when staus is changed)
4439: OKC_CVM_PVT.g_trans_id := 'XX-XX';
4440: --- Added for Bug# 2606251 ---
4441:
4442: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
4443: EXCEPTION
4444: WHEN OKC_API.G_EXCEPTION_ERROR THEN
4445: x_return_status := OKC_API.HANDLE_EXCEPTIONS
4446: (

Line 4444: WHEN OKC_API.G_EXCEPTION_ERROR THEN

4440: --- Added for Bug# 2606251 ---
4441:
4442: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
4443: EXCEPTION
4444: WHEN OKC_API.G_EXCEPTION_ERROR THEN
4445: x_return_status := OKC_API.HANDLE_EXCEPTIONS
4446: (
4447: l_api_name,
4448: G_PKG_NAME,

Line 4445: x_return_status := OKC_API.HANDLE_EXCEPTIONS

4441:
4442: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
4443: EXCEPTION
4444: WHEN OKC_API.G_EXCEPTION_ERROR THEN
4445: x_return_status := OKC_API.HANDLE_EXCEPTIONS
4446: (
4447: l_api_name,
4448: G_PKG_NAME,
4449: 'OKC_API.G_RET_STS_ERROR',

Line 4449: 'OKC_API.G_RET_STS_ERROR',

4445: x_return_status := OKC_API.HANDLE_EXCEPTIONS
4446: (
4447: l_api_name,
4448: G_PKG_NAME,
4449: 'OKC_API.G_RET_STS_ERROR',
4450: x_msg_count,
4451: x_msg_data,
4452: '_PVT'
4453: );

Line 4454: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

4450: x_msg_count,
4451: x_msg_data,
4452: '_PVT'
4453: );
4454: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
4455: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
4456: (
4457: l_api_name,
4458: G_PKG_NAME,

Line 4455: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

4451: x_msg_data,
4452: '_PVT'
4453: );
4454: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
4455: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
4456: (
4457: l_api_name,
4458: G_PKG_NAME,
4459: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 4459: 'OKC_API.G_RET_STS_UNEXP_ERROR',

4455: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
4456: (
4457: l_api_name,
4458: G_PKG_NAME,
4459: 'OKC_API.G_RET_STS_UNEXP_ERROR',
4460: x_msg_count,
4461: x_msg_data,
4462: '_PVT'
4463: );

Line 4465: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

4461: x_msg_data,
4462: '_PVT'
4463: );
4464: WHEN OTHERS THEN
4465: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
4466: (
4467: l_api_name,
4468: G_PKG_NAME,
4469: 'OTHERS',

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

4501: FUNCTION Get_concat_line_no(
4502: p_cle_id IN NUMBER,
4503: x_return_status OUT NOCOPY Varchar2) RETURN VARCHAR2 IS
4504:
4505: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
4506:
4507: CURSOR l_line_csr IS
4508: SELECT display_sequence from
4509: OKC_K_LINES_B

Line 4602: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

4598: x_return_status := l_return_status;
4599: End if;
4600: EXCEPTION
4601: WHEN OTHERS then
4602: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
4603: OKC_API.SET_MESSAGE(p_app_name => g_app_name,
4604: p_msg_name => g_unexpected_error,
4605: p_token1 => g_sqlcode_token,
4606: p_token1_value => sqlcode,

Line 4603: OKC_API.SET_MESSAGE(p_app_name => g_app_name,

4599: End if;
4600: EXCEPTION
4601: WHEN OTHERS then
4602: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
4603: OKC_API.SET_MESSAGE(p_app_name => g_app_name,
4604: p_msg_name => g_unexpected_error,
4605: p_token1 => g_sqlcode_token,
4606: p_token1_value => sqlcode,
4607: p_token2 => g_sqlerrm_token,

Line 4635: p_init_msg_list IN VARCHAR2 DEFAULT OKC_API.G_FALSE,

4631:
4632:
4633: PROCEDURE UPDATE_CONTRACT_AMOUNT (
4634: p_api_version IN NUMBER,
4635: p_init_msg_list IN VARCHAR2 DEFAULT OKC_API.G_FALSE,
4636: p_id IN NUMBER,
4637: p_from_ste_code IN VARCHAR2,
4638: p_to_ste_code IN VARCHAR2,
4639: p_cle_id IN NUMBER,

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

5069: is
5070:
5071: l_source_code VARCHAR2(30):= 'DUMMY';
5072: l_api_name VARCHAR2(30) := 'CLEAN_REN_LINKS';
5073: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
5074: l_active_yn VARCHAR2(1) := 'N';
5075:
5076: l_object_cle_id NUMBER;
5077:

Line 5093: x_return_status := OKC_API.G_RET_STS_SUCCESS;

5089: (opl.subject_cle_id= olb.id )
5090: );
5091:
5092: BEGIN
5093: x_return_status := OKC_API.G_RET_STS_SUCCESS;
5094:
5095: -- set flag to update
5096: IF (NVL(clean_relink_flag,'CLEAN') = 'RELINK') Then
5097: l_active_yn := 'Y';

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

5161: --Set minor version for updated contracts
5162: --
5163: x_return_status := update_minor_version(p_target_chr_id);
5164:
5165: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
5166: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
5167: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
5168: raise OKC_API.G_EXCEPTION_ERROR;
5169: END IF;

Line 5166: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

5162: --
5163: x_return_status := update_minor_version(p_target_chr_id);
5164:
5165: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
5166: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
5167: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
5168: raise OKC_API.G_EXCEPTION_ERROR;
5169: END IF;
5170:

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

5163: x_return_status := update_minor_version(p_target_chr_id);
5164:
5165: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
5166: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
5167: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
5168: raise OKC_API.G_EXCEPTION_ERROR;
5169: END IF;
5170:
5171:

Line 5168: raise OKC_API.G_EXCEPTION_ERROR;

5164:
5165: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
5166: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
5167: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
5168: raise OKC_API.G_EXCEPTION_ERROR;
5169: END IF;
5170:
5171:
5172: OKC_CVM_PVT.g_trans_id := 'XX-XX';

Line 5175: WHEN OKC_API.G_EXCEPTION_ERROR THEN

5171:
5172: OKC_CVM_PVT.g_trans_id := 'XX-XX';
5173:
5174: EXCEPTION
5175: WHEN OKC_API.G_EXCEPTION_ERROR THEN
5176: x_return_status := OKC_API.HANDLE_EXCEPTIONS
5177: (
5178: l_api_name,
5179: G_PKG_NAME,

Line 5176: x_return_status := OKC_API.HANDLE_EXCEPTIONS

5172: OKC_CVM_PVT.g_trans_id := 'XX-XX';
5173:
5174: EXCEPTION
5175: WHEN OKC_API.G_EXCEPTION_ERROR THEN
5176: x_return_status := OKC_API.HANDLE_EXCEPTIONS
5177: (
5178: l_api_name,
5179: G_PKG_NAME,
5180: 'OKC_API.G_RET_STS_ERROR',

Line 5180: 'OKC_API.G_RET_STS_ERROR',

5176: x_return_status := OKC_API.HANDLE_EXCEPTIONS
5177: (
5178: l_api_name,
5179: G_PKG_NAME,
5180: 'OKC_API.G_RET_STS_ERROR',
5181: x_msg_count,
5182: x_msg_data,
5183: '_PVT'
5184: );

Line 5185: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

5181: x_msg_count,
5182: x_msg_data,
5183: '_PVT'
5184: );
5185: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
5186: x_return_status := OKC_API.HANDLE_EXCEPTIONS
5187: (
5188: l_api_name,
5189: G_PKG_NAME,

Line 5186: x_return_status := OKC_API.HANDLE_EXCEPTIONS

5182: x_msg_data,
5183: '_PVT'
5184: );
5185: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
5186: x_return_status := OKC_API.HANDLE_EXCEPTIONS
5187: (
5188: l_api_name,
5189: G_PKG_NAME,
5190: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 5190: 'OKC_API.G_RET_STS_UNEXP_ERROR',

5186: x_return_status := OKC_API.HANDLE_EXCEPTIONS
5187: (
5188: l_api_name,
5189: G_PKG_NAME,
5190: 'OKC_API.G_RET_STS_UNEXP_ERROR',
5191: x_msg_count,
5192: x_msg_data,
5193: '_PVT'
5194: );

Line 5196: x_return_status := OKC_API.HANDLE_EXCEPTIONS

5192: x_msg_data,
5193: '_PVT'
5194: );
5195: WHEN OTHERS THEN
5196: x_return_status := OKC_API.HANDLE_EXCEPTIONS
5197: (
5198: l_api_name,
5199: G_PKG_NAME,
5200: 'OTHERS',