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

APPS.LNS_BILLING_BATCH_PUB dependencies on FND_API

Line 175: RAISE FND_API.G_EXC_ERROR;

171: FND_MESSAGE.SET_NAME('LNS', 'LNS_NO_SYSTEM_OPTIONS');
172: FND_MESSAGE.SET_TOKEN('ORG', g_org_id);
173: FND_MSG_PUB.Add;
174: LogMessage(FND_LOG.LEVEL_UNEXPECTED, FND_MSG_PUB.Get(p_encoded => 'F'));
175: RAISE FND_API.G_EXC_ERROR;
176:
177: elsif g_sys_opt_num > 1 then
178:
179: -- LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'ERROR: Found more then 1 system options records for the org ' || g_org_id);

Line 184: RAISE FND_API.G_EXC_ERROR;

180: FND_MESSAGE.SET_NAME('LNS', 'LNS_MANY_SYSTEM_OPTIONS');
181: FND_MESSAGE.SET_TOKEN('ORG', g_org_id);
182: FND_MSG_PUB.Add;
183: LogMessage(FND_LOG.LEVEL_UNEXPECTED, FND_MSG_PUB.Get(p_encoded => 'F'));
184: RAISE FND_API.G_EXC_ERROR;
185:
186: end if;
187:
188: /* getting system options */

Line 233: RAISE FND_API.G_EXC_ERROR;

229: -- LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'ERROR: Batch Source is not set in the system option.');
230: FND_MESSAGE.SET_NAME('LNS', 'LNS_NO_BATCH_IN_SYS_OPT');
231: FND_MSG_PUB.Add;
232: LogMessage(FND_LOG.LEVEL_UNEXPECTED, FND_MSG_PUB.Get(p_encoded => 'F'));
233: RAISE FND_API.G_EXC_ERROR;
234:
235: end if;
236:
237: if g_trx_type_id is null then

Line 243: RAISE FND_API.G_EXC_ERROR;

239: -- LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'ERROR: Default Transaction Type is not set in the system option.');
240: FND_MESSAGE.SET_NAME('LNS', 'LNS_NO_TRX_TYPE_IN_SYS_OPT');
241: FND_MSG_PUB.Add;
242: LogMessage(FND_LOG.LEVEL_UNEXPECTED, FND_MSG_PUB.Get(p_encoded => 'F'));
243: RAISE FND_API.G_EXC_ERROR;
244:
245: end if;
246:
247: if g_multiple_lines is null then

Line 253: RAISE FND_API.G_EXC_ERROR;

249: -- LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'ERROR: Combination Invoice is not set in the system option.');
250: FND_MESSAGE.SET_NAME('LNS', 'LNS_NO_INV_COMB_IN_SYS_OPT');
251: FND_MSG_PUB.Add;
252: LogMessage(FND_LOG.LEVEL_UNEXPECTED, FND_MSG_PUB.Get(p_encoded => 'F'));
253: RAISE FND_API.G_EXC_ERROR;
254:
255: end if;
256:
257: LogMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME || '.' || l_api_name || ' -');

Line 395: l_loan_header_rec.LAST_PAYMENT_NUMBER := FND_API.G_MISS_NUM;

391: /* updating loan header table */
392: l_loan_header_rec.loan_id := l_loan_id;
393:
394: if l_last_payment_number is null then
395: l_loan_header_rec.LAST_PAYMENT_NUMBER := FND_API.G_MISS_NUM;
396: else
397: l_loan_header_rec.LAST_PAYMENT_NUMBER := l_last_payment_number;
398: end if;
399:

Line 401: l_loan_header_rec.LAST_AMORTIZATION_ID := FND_API.G_MISS_NUM;

397: l_loan_header_rec.LAST_PAYMENT_NUMBER := l_last_payment_number;
398: end if;
399:
400: if l_amortization_id is null then
401: l_loan_header_rec.LAST_AMORTIZATION_ID := FND_API.G_MISS_NUM;
402: else
403: l_loan_header_rec.LAST_AMORTIZATION_ID := l_amortization_id;
404: end if;
405:

Line 410: P_INIT_MSG_LIST => FND_API.G_FALSE,

406: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Updating loan header...');
407:
408: LNS_LOAN_HEADER_PUB.UPDATE_LOAN(P_OBJECT_VERSION_NUMBER => l_version_number,
409: P_LOAN_HEADER_REC => l_loan_header_rec,
410: P_INIT_MSG_LIST => FND_API.G_FALSE,
411: X_RETURN_STATUS => l_return_status,
412: X_MSG_COUNT => l_msg_count,
413: X_MSG_DATA => l_msg_data);
414:

Line 423: RAISE FND_API.G_EXC_ERROR;

419: ELSE
420: FND_MESSAGE.SET_NAME('LNS', 'LNS_UPD_LOAN_FAIL');
421: FND_MSG_PUB.Add;
422: LogMessage(FND_LOG.LEVEL_UNEXPECTED, FND_MSG_PUB.Get(p_encoded => 'F'));
423: RAISE FND_API.G_EXC_ERROR;
424: END IF;
425:
426: LogMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME || '.' || l_api_name || ' -');
427:

Line 537: IF FND_API.to_Boolean(p_init_msg_list) THEN

533: -- Standard Start of API savepoint
534: SAVEPOINT PROCESS_PAID_LOANS;
535:
536: -- Initialize message list IF p_init_msg_list is set to TRUE.
537: IF FND_API.to_Boolean(p_init_msg_list) THEN
538: FND_MSG_PUB.initialize;
539: END IF;
540:
541: -- Initialize API return status to SUCCESS

Line 542: x_return_status := FND_API.G_RET_STS_SUCCESS;

538: FND_MSG_PUB.initialize;
539: END IF;
540:
541: -- Initialize API return status to SUCCESS
542: x_return_status := FND_API.G_RET_STS_SUCCESS;
543:
544: --
545: -- Api body
546: -- ----------------------------------------------------------------

Line 575: P_INIT_MSG_LIST => FND_API.G_TRUE,

571: if l_remaining_amount = 0 then
572:
573: LNS_FUNDING_PUB.VALIDATE_DISB_FOR_PAYOFF(
574: P_API_VERSION => 1.0,
575: P_INIT_MSG_LIST => FND_API.G_TRUE,
576: P_COMMIT => FND_API.G_FALSE,
577: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,
578: P_LOAN_ID => l_loan_id,
579: X_RETURN_STATUS => l_return_status,

Line 576: P_COMMIT => FND_API.G_FALSE,

572:
573: LNS_FUNDING_PUB.VALIDATE_DISB_FOR_PAYOFF(
574: P_API_VERSION => 1.0,
575: P_INIT_MSG_LIST => FND_API.G_TRUE,
576: P_COMMIT => FND_API.G_FALSE,
577: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,
578: P_LOAN_ID => l_loan_id,
579: X_RETURN_STATUS => l_return_status,
580: X_MSG_COUNT => l_msg_count,

Line 577: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,

573: LNS_FUNDING_PUB.VALIDATE_DISB_FOR_PAYOFF(
574: P_API_VERSION => 1.0,
575: P_INIT_MSG_LIST => FND_API.G_TRUE,
576: P_COMMIT => FND_API.G_FALSE,
577: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,
578: P_LOAN_ID => l_loan_id,
579: X_RETURN_STATUS => l_return_status,
580: X_MSG_COUNT => l_msg_count,
581: X_MSG_DATA => l_msg_data);

Line 584: RAISE FND_API.G_EXC_ERROR;

580: X_MSG_COUNT => l_msg_count,
581: X_MSG_DATA => l_msg_data);
582:
583: IF l_return_status <> 'S' THEN
584: RAISE FND_API.G_EXC_ERROR;
585: END IF;
586:
587: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Updating lns_fee_assignments...');
588: update lns_fee_assignments

Line 606: l_loan_header_rec.SECONDARY_STATUS := FND_API.G_MISS_CHAR;

602:
603: /* updating loan header table */
604: l_loan_header_rec.loan_id := l_loan_id;
605: l_loan_header_rec.LOAN_STATUS := 'PAIDOFF';
606: l_loan_header_rec.SECONDARY_STATUS := FND_API.G_MISS_CHAR;
607:
608: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Updating loan header info w following values:');
609: LogMessage(FND_LOG.LEVEL_STATEMENT, 'LOAN_STATUS: ' || l_loan_header_rec.LOAN_STATUS);
610: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Secondary status: ' || l_loan_header_rec.SECONDARY_STATUS);

Line 614: P_INIT_MSG_LIST => FND_API.G_FALSE,

610: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Secondary status: ' || l_loan_header_rec.SECONDARY_STATUS);
611:
612: LNS_LOAN_HEADER_PUB.UPDATE_LOAN(P_OBJECT_VERSION_NUMBER => l_version_number,
613: P_LOAN_HEADER_REC => l_loan_header_rec,
614: P_INIT_MSG_LIST => FND_API.G_FALSE,
615: X_RETURN_STATUS => l_return_status,
616: X_MSG_COUNT => l_msg_count,
617: X_MSG_DATA => l_msg_data);
618:

Line 627: RAISE FND_API.G_EXC_ERROR;

623: ELSE
624: FND_MESSAGE.SET_NAME('LNS', 'LNS_UPD_LOAN_FAIL');
625: FND_MSG_PUB.Add;
626: LogMessage(FND_LOG.LEVEL_UNEXPECTED, FND_MSG_PUB.Get(p_encoded => 'F'));
627: RAISE FND_API.G_EXC_ERROR;
628: END IF;
629:
630: if P_COMMIT = FND_API.G_TRUE then
631: COMMIT WORK;

Line 630: if P_COMMIT = FND_API.G_TRUE then

626: LogMessage(FND_LOG.LEVEL_UNEXPECTED, FND_MSG_PUB.Get(p_encoded => 'F'));
627: RAISE FND_API.G_EXC_ERROR;
628: END IF;
629:
630: if P_COMMIT = FND_API.G_TRUE then
631: COMMIT WORK;
632: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Commited');
633: end if;
634:

Line 661: WHEN FND_API.G_EXC_ERROR THEN

657: LogMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME || '.' || l_api_name || ' -');
658:
659: EXCEPTION
660:
661: WHEN FND_API.G_EXC_ERROR THEN
662: ROLLBACK TO PROCESS_PAID_LOANS;
663: x_return_status := FND_API.G_RET_STS_ERROR;
664: logMessage(FND_LOG.LEVEL_ERROR, sqlerrm);
665:

Line 663: x_return_status := FND_API.G_RET_STS_ERROR;

659: EXCEPTION
660:
661: WHEN FND_API.G_EXC_ERROR THEN
662: ROLLBACK TO PROCESS_PAID_LOANS;
663: x_return_status := FND_API.G_RET_STS_ERROR;
664: logMessage(FND_LOG.LEVEL_ERROR, sqlerrm);
665:
666: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
667: ROLLBACK TO PROCESS_PAID_LOANS;

Line 666: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN

662: ROLLBACK TO PROCESS_PAID_LOANS;
663: x_return_status := FND_API.G_RET_STS_ERROR;
664: logMessage(FND_LOG.LEVEL_ERROR, sqlerrm);
665:
666: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
667: ROLLBACK TO PROCESS_PAID_LOANS;
668: x_return_status := FND_API.G_RET_STS_ERROR;
669: logMessage(FND_LOG.LEVEL_ERROR, sqlerrm);
670:

Line 668: x_return_status := FND_API.G_RET_STS_ERROR;

664: logMessage(FND_LOG.LEVEL_ERROR, sqlerrm);
665:
666: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
667: ROLLBACK TO PROCESS_PAID_LOANS;
668: x_return_status := FND_API.G_RET_STS_ERROR;
669: logMessage(FND_LOG.LEVEL_ERROR, sqlerrm);
670:
671: WHEN OTHERS THEN
672: ROLLBACK TO PROCESS_PAID_LOANS;

Line 673: x_return_status := FND_API.G_RET_STS_ERROR;

669: logMessage(FND_LOG.LEVEL_ERROR, sqlerrm);
670:
671: WHEN OTHERS THEN
672: ROLLBACK TO PROCESS_PAID_LOANS;
673: x_return_status := FND_API.G_RET_STS_ERROR;
674: logMessage(FND_LOG.LEVEL_ERROR, sqlerrm);
675:
676: END;
677:

Line 787: P_INIT_MSG_LIST => FND_API.G_FALSE,

783: LogMessage(FND_LOG.LEVEL_STATEMENT, 'LOAN_STATUS: ' || l_loan_header_rec.LOAN_STATUS);
784:
785: LNS_LOAN_HEADER_PUB.UPDATE_LOAN(P_OBJECT_VERSION_NUMBER => l_version_number,
786: P_LOAN_HEADER_REC => l_loan_header_rec,
787: P_INIT_MSG_LIST => FND_API.G_FALSE,
788: X_RETURN_STATUS => l_return_status,
789: X_MSG_COUNT => l_msg_count,
790: X_MSG_DATA => l_msg_data);
791:

Line 800: RAISE FND_API.G_EXC_ERROR;

796: ELSE
797: FND_MESSAGE.SET_NAME('LNS', 'LNS_UPD_LOAN_FAIL');
798: FND_MSG_PUB.Add;
799: LogMessage(FND_LOG.LEVEL_ERROR, FND_MSG_PUB.Get(p_encoded => 'F'));
800: RAISE FND_API.G_EXC_ERROR;
801: END IF;
802:
803: if P_COMMIT = FND_API.G_TRUE then
804: COMMIT WORK;

Line 803: if P_COMMIT = FND_API.G_TRUE then

799: LogMessage(FND_LOG.LEVEL_ERROR, FND_MSG_PUB.Get(p_encoded => 'F'));
800: RAISE FND_API.G_EXC_ERROR;
801: END IF;
802:
803: if P_COMMIT = FND_API.G_TRUE then
804: COMMIT WORK;
805: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Commited');
806: end if;
807:

Line 1243: RAISE FND_API.G_EXC_ERROR;

1239: FND_MESSAGE.SET_NAME('LNS', 'LNS_BILLING_DISABLED');
1240: FND_MESSAGE.SET_TOKEN('LOAN_NUMBER', p_loan_rec.loan_number);
1241: FND_MSG_PUB.Add;
1242: LogMessage(FND_LOG.LEVEL_UNEXPECTED, FND_MSG_PUB.Get(p_encoded => 'F'));
1243: RAISE FND_API.G_EXC_ERROR;
1244: END IF;
1245:
1246: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Preparing to call AR invoice api...');
1247:

Line 1522: RAISE FND_API.G_EXC_ERROR;

1518: -- LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'ERROR: Interest transaction type is not set.');
1519: FND_MESSAGE.SET_NAME('LNS', 'LNS_NO_INT_TRX_TYPE_IN_SYS_OPT');
1520: FND_MSG_PUB.Add;
1521: LogMessage(FND_LOG.LEVEL_UNEXPECTED, FND_MSG_PUB.Get(p_encoded => 'F'));
1522: RAISE FND_API.G_EXC_ERROR;
1523:
1524: end if;
1525:
1526: l_trx_header_tbl(l_Count3).cust_trx_type_id := g_int_trx_type_id;

Line 1591: RAISE FND_API.G_EXC_ERROR;

1587: -- LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'ERROR: Fee transaction type is not set.');
1588: FND_MESSAGE.SET_NAME('LNS', 'LNS_NO_FEE_TRX_TYPE_IN_SYS_OPT');
1589: FND_MSG_PUB.Add;
1590: LogMessage(FND_LOG.LEVEL_UNEXPECTED, FND_MSG_PUB.Get(p_encoded => 'F'));
1591: RAISE FND_API.G_EXC_ERROR;
1592:
1593: end if;
1594:
1595: l_trx_header_tbl(l_Count3).cust_trx_type_id := g_fee_trx_type_id;

Line 2010: RAISE FND_API.G_EXC_ERROR;

2006: -- LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'ERROR: No data to create invoices.');
2007: FND_MESSAGE.SET_NAME('LNS', 'LNS_NO_DATA_CR_INV');
2008: FND_MSG_PUB.Add;
2009: LogMessage(FND_LOG.LEVEL_UNEXPECTED, FND_MSG_PUB.Get(p_encoded => 'F'));
2010: RAISE FND_API.G_EXC_ERROR;
2011: */
2012:
2013: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Creating AR invoices with following values:');
2014: LogMessage(FND_LOG.LEVEL_STATEMENT, 'l_batch_source_rec.batch_source_id: ' || l_batch_source_rec.batch_source_id);

Line 2103: p_init_msg_list => FND_API.G_TRUE,

2099: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Calling AR_INVOICE_API_PUB.CREATE_INVOICE...');
2100: l_start := sysdate;
2101: AR_INVOICE_API_PUB.CREATE_INVOICE(
2102: p_api_version => 1.0,
2103: p_init_msg_list => FND_API.G_TRUE,
2104: p_commit => FND_API.G_FALSE,
2105: p_batch_source_rec => l_batch_source_rec,
2106: p_trx_header_tbl => l_trx_header_tbl,
2107: p_trx_lines_tbl => l_trx_lines_tbl,

Line 2104: p_commit => FND_API.G_FALSE,

2100: l_start := sysdate;
2101: AR_INVOICE_API_PUB.CREATE_INVOICE(
2102: p_api_version => 1.0,
2103: p_init_msg_list => FND_API.G_TRUE,
2104: p_commit => FND_API.G_FALSE,
2105: p_batch_source_rec => l_batch_source_rec,
2106: p_trx_header_tbl => l_trx_header_tbl,
2107: p_trx_lines_tbl => l_trx_lines_tbl,
2108: p_trx_dist_tbl => l_trx_dist_tbl,

Line 2159: RAISE FND_API.G_EXC_ERROR;

2155: if l_ar_error_counter = 0 then
2156: LogMessage(FND_LOG.LEVEL_ERROR, 'No AR errors found.');
2157: end if;
2158:
2159: RAISE FND_API.G_EXC_ERROR;
2160: END;
2161:
2162: l_end := sysdate;
2163: LogMessage(FND_LOG.LEVEL_PROCEDURE, 'Invoice API timing: ' || round((l_end - l_start)*86400, 2) || ' sec');

Line 2172: IF l_return_status = fnd_api.g_ret_sts_error OR l_return_status = fnd_api.g_ret_sts_unexp_error OR l_batch_id is null THEN

2168: LogMessage(FND_LOG.LEVEL_STATEMENT, 'l_msg_data: ' || substr(l_msg_data,1,225));
2169: LogMessage(FND_LOG.LEVEL_STATEMENT, 'l_batch_id: ' || l_batch_id);
2170:
2171: l_ar_error_counter := 0;
2172: IF l_return_status = fnd_api.g_ret_sts_error OR l_return_status = fnd_api.g_ret_sts_unexp_error OR l_batch_id is null THEN
2173:
2174: l_ar_error_counter := 1;
2175: FND_MESSAGE.SET_NAME('LNS', 'LNS_CR_INV_FAIL');
2176: FND_MESSAGE.SET_TOKEN('MSG', l_msg_data);

Line 2208: RAISE FND_API.G_EXC_ERROR;

2204:
2205: close ar_invoice_err_cur;
2206:
2207: if l_ar_error_counter > 0 then
2208: RAISE FND_API.G_EXC_ERROR;
2209: else
2210: l_ar_inv_created := true;
2211: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Invoices successfully created!') ;
2212: end if;

Line 2353: RAISE FND_API.G_EXC_ERROR;

2349: -- LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'ERROR: No AR invoices fetched');
2350: FND_MESSAGE.SET_NAME('LNS', 'LNS_NO_INV_FETCHED');
2351: FND_MSG_PUB.Add;
2352: LogMessage(FND_LOG.LEVEL_ERROR, FND_MSG_PUB.Get(p_encoded => 'F'));
2353: RAISE FND_API.G_EXC_ERROR;
2354: end if;
2355:
2356: /* Update interest and fee trxs with principal_trx_id as RELATED_CUSTOMER_TRX_ID */
2357: if g_multiple_lines = 'N' and l_principal_trx_id is not null then

Line 2368: RAISE FND_API.G_EXC_ERROR;

2364: -- LogMessage(FND_LOG.LEVEL_ERROR, 'ERROR: Update RA_CUSTOMER_TRX_ALL with RELATED_CUSTOMER_TRX_ID failed');
2365: FND_MESSAGE.SET_NAME('LNS', 'LNS_RELATE_INV_FAIL');
2366: FND_MSG_PUB.Add;
2367: LogMessage(FND_LOG.LEVEL_ERROR, FND_MSG_PUB.Get(p_encoded => 'F'));
2368: RAISE FND_API.G_EXC_ERROR;
2369: end if;
2370:
2371: end if;
2372:

Line 2382: RAISE FND_API.G_EXC_ERROR;

2378: -- LogMessage(FND_LOG.LEVEL_ERROR, 'ERROR: Update RA_CUSTOMER_TRX_ALL with RELATED_CUSTOMER_TRX_ID failed');
2379: FND_MESSAGE.SET_NAME('LNS', 'LNS_RELATE_INV_FAIL');
2380: FND_MSG_PUB.Add;
2381: LogMessage(FND_LOG.LEVEL_ERROR, FND_MSG_PUB.Get(p_encoded => 'F'));
2382: RAISE FND_API.G_EXC_ERROR;
2383: end if;
2384:
2385: end if;
2386:

Line 2507: RAISE FND_API.G_EXC_ERROR;

2503: -- LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'ERROR: Cannot reverse because there are some valid activities on trx.');
2504: FND_MESSAGE.SET_NAME('LNS', 'LNS_CANT_REV_BILL');
2505: FND_MSG_PUB.Add;
2506: LogMessage(FND_LOG.LEVEL_ERROR, FND_MSG_PUB.Get(p_encoded => 'F'));
2507: RAISE FND_API.G_EXC_ERROR;
2508:
2509: end if;
2510:
2511: /* searching/adding trx(s) into unique trx table */

Line 2543: RAISE FND_API.G_EXC_ERROR;

2539: -- LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'ERROR: No AR transactions found to reverse.');
2540: FND_MESSAGE.SET_NAME('LNS', 'LNS_NO_TRX_REVERSE');
2541: FND_MSG_PUB.Add;
2542: LogMessage(FND_LOG.LEVEL_ERROR, FND_MSG_PUB.Get(p_encoded => 'F'));
2543: RAISE FND_API.G_EXC_ERROR;
2544:
2545: end if;
2546:
2547: /* query for batch_source_name and cm_batch_source_id */

Line 2558: RAISE FND_API.G_EXC_ERROR;

2554: FND_MESSAGE.SET_NAME('LNS', 'LNS_NO_CM_BATCH');
2555: FND_MESSAGE.SET_TOKEN('BATCH', l_batch_source_name);
2556: FND_MSG_PUB.Add;
2557: LogMessage(FND_LOG.LEVEL_ERROR, FND_MSG_PUB.Get(p_encoded => 'F'));
2558: RAISE FND_API.G_EXC_ERROR;
2559:
2560: end if;
2561:
2562: /* query for cm_batch_source_name */

Line 2617: P_INIT_MSG_LIST => FND_API.G_TRUE,

2613:
2614: begin
2615: AR_CREDIT_MEMO_API_PUB.CREATE_REQUEST(
2616: P_API_VERSION => 1.0,
2617: P_INIT_MSG_LIST => FND_API.G_TRUE,
2618: P_COMMIT => FND_API.G_FALSE,
2619: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,
2620: P_CUSTOMER_TRX_ID => l_trx_tbl(l_Count1),
2621: P_LINE_CREDIT_FLAG => l_LINE_CREDIT_FLAG,

Line 2618: P_COMMIT => FND_API.G_FALSE,

2614: begin
2615: AR_CREDIT_MEMO_API_PUB.CREATE_REQUEST(
2616: P_API_VERSION => 1.0,
2617: P_INIT_MSG_LIST => FND_API.G_TRUE,
2618: P_COMMIT => FND_API.G_FALSE,
2619: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,
2620: P_CUSTOMER_TRX_ID => l_trx_tbl(l_Count1),
2621: P_LINE_CREDIT_FLAG => l_LINE_CREDIT_FLAG,
2622: p_line_amount => l_amount,

Line 2619: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,

2615: AR_CREDIT_MEMO_API_PUB.CREATE_REQUEST(
2616: P_API_VERSION => 1.0,
2617: P_INIT_MSG_LIST => FND_API.G_TRUE,
2618: P_COMMIT => FND_API.G_FALSE,
2619: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,
2620: P_CUSTOMER_TRX_ID => l_trx_tbl(l_Count1),
2621: P_LINE_CREDIT_FLAG => l_LINE_CREDIT_FLAG,
2622: p_line_amount => l_amount,
2623: P_CM_REASON_CODE => 'CANCELLATION',

Line 2638: RAISE FND_API.G_EXC_ERROR;

2634:
2635: EXCEPTION
2636: WHEN OTHERS THEN
2637: LogMessage(FND_LOG.LEVEL_ERROR, 'ERROR: ' || sqlerrm);
2638: RAISE FND_API.G_EXC_ERROR;
2639: end;
2640:
2641: LogMessage(FND_LOG.LEVEL_STATEMENT, 'l_return_status: ' || l_return_status);
2642: LogMessage(FND_LOG.LEVEL_STATEMENT, 'l_msg_data: ' || substr(l_msg_data,1,225));

Line 2645: IF l_return_status = fnd_api.g_ret_sts_error OR l_return_status = fnd_api.g_ret_sts_unexp_error OR

2641: LogMessage(FND_LOG.LEVEL_STATEMENT, 'l_return_status: ' || l_return_status);
2642: LogMessage(FND_LOG.LEVEL_STATEMENT, 'l_msg_data: ' || substr(l_msg_data,1,225));
2643: LogMessage(FND_LOG.LEVEL_STATEMENT, 'l_request_id: ' || l_request_id);
2644:
2645: IF l_return_status = fnd_api.g_ret_sts_error OR l_return_status = fnd_api.g_ret_sts_unexp_error OR
2646: l_request_id is null OR l_request_id = -1
2647:
2648: THEN
2649:

Line 2655: RAISE FND_API.G_EXC_ERROR;

2651: FND_MESSAGE.SET_NAME('LNS', 'LNS_CR_CM_FAIL');
2652: FND_MESSAGE.SET_TOKEN('BATCH', l_cm_batch_source_name);
2653: FND_MSG_PUB.Add;
2654: LogMessage(FND_LOG.LEVEL_ERROR, FND_MSG_PUB.Get(p_encoded => 'F'));
2655: RAISE FND_API.G_EXC_ERROR;
2656:
2657: ELSE
2658:
2659: if l_msg_data is not null then

Line 2750: RAISE FND_API.G_EXC_ERROR;

2746: -- LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'ERROR: Cash Receipt ID is not set.');
2747: FND_MESSAGE.SET_NAME('LNS', 'LNS_CR_NOT_SET');
2748: FND_MSG_PUB.Add;
2749: LogMessage(FND_LOG.LEVEL_ERROR, FND_MSG_PUB.Get(p_encoded => 'F'));
2750: RAISE FND_API.G_EXC_ERROR;
2751: end if;
2752:
2753: if P_TRX_ID is null then
2754: -- LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'ERROR: Trx ID is not set.');

Line 2758: RAISE FND_API.G_EXC_ERROR;

2754: -- LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'ERROR: Trx ID is not set.');
2755: FND_MESSAGE.SET_NAME('LNS', 'LNS_TRX_NOT_SET');
2756: FND_MSG_PUB.Add;
2757: LogMessage(FND_LOG.LEVEL_ERROR, FND_MSG_PUB.Get(p_encoded => 'F'));
2758: RAISE FND_API.G_EXC_ERROR;
2759: end if;
2760:
2761: if P_TRX_LINE_ID is null then
2762: -- LogMessage(FND_LOG.LEVEL_ERROR, 'ERROR: Trx Line ID is not set.');

Line 2766: RAISE FND_API.G_EXC_ERROR;

2762: -- LogMessage(FND_LOG.LEVEL_ERROR, 'ERROR: Trx Line ID is not set.');
2763: FND_MESSAGE.SET_NAME('LNS', 'LNS_TRX_LINE_NOT_SET');
2764: FND_MSG_PUB.Add;
2765: LogMessage(FND_LOG.LEVEL_ERROR, FND_MSG_PUB.Get(p_encoded => 'F'));
2766: RAISE FND_API.G_EXC_ERROR;
2767: end if;
2768:
2769: if P_APPLY_AMOUNT is null or P_APPLY_AMOUNT <= 0 then
2770: -- LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'ERROR: Apply Amount is not set.');

Line 2774: RAISE FND_API.G_EXC_ERROR;

2770: -- LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'ERROR: Apply Amount is not set.');
2771: FND_MESSAGE.SET_NAME('LNS', 'LNS_AMOUNT_NOT_SET');
2772: FND_MSG_PUB.Add;
2773: LogMessage(FND_LOG.LEVEL_ERROR, FND_MSG_PUB.Get(p_encoded => 'F'));
2774: RAISE FND_API.G_EXC_ERROR;
2775: end if;
2776:
2777: /* verifying requested qpply amount */
2778:

Line 2787: RAISE FND_API.G_EXC_ERROR;

2783: -- LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'ERROR: No receipt found to apply.');
2784: FND_MESSAGE.SET_NAME('LNS', 'LNS_NO_CR_FOUND');
2785: FND_MSG_PUB.Add;
2786: LogMessage(FND_LOG.LEVEL_ERROR, FND_MSG_PUB.Get(p_encoded => 'F'));
2787: RAISE FND_API.G_EXC_ERROR;
2788: end if;
2789:
2790: close receipt_cur;
2791:

Line 2797: RAISE FND_API.G_EXC_ERROR;

2793: -- LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'ERROR: The receipt does not have enough funds to apply requested amount.');
2794: FND_MESSAGE.SET_NAME('LNS', 'LNS_NO_CR_FUNDS');
2795: FND_MSG_PUB.Add;
2796: LogMessage(FND_LOG.LEVEL_ERROR, FND_MSG_PUB.Get(p_encoded => 'F'));
2797: RAISE FND_API.G_EXC_ERROR;
2798: end if;
2799:
2800: /* Applying cash receipt to invoice */
2801: /*

Line 2804: P_INIT_MSG_LIST => FND_API.G_FALSE,

2800: /* Applying cash receipt to invoice */
2801: /*
2802: AR_RECEIPT_API_PUB.APPLY(
2803: P_API_VERSION => 1.0,
2804: P_INIT_MSG_LIST => FND_API.G_FALSE,
2805: P_COMMIT => FND_API.G_TRUE,
2806: X_RETURN_STATUS => L_RETURN_STATUS,
2807: X_MSG_COUNT => L_MSG_COUNT,
2808: X_MSG_DATA => L_MSG_DATA,

Line 2805: P_COMMIT => FND_API.G_TRUE,

2801: /*
2802: AR_RECEIPT_API_PUB.APPLY(
2803: P_API_VERSION => 1.0,
2804: P_INIT_MSG_LIST => FND_API.G_FALSE,
2805: P_COMMIT => FND_API.G_TRUE,
2806: X_RETURN_STATUS => L_RETURN_STATUS,
2807: X_MSG_COUNT => L_MSG_COUNT,
2808: X_MSG_DATA => L_MSG_DATA,
2809: p_cash_receipt_id => P_CASH_RECEIPT_ID,

Line 2817: IF l_return_status <> FND_API.G_RET_STS_SUCCESS THEN

2813: */
2814: LogMessage(FND_LOG.LEVEL_STATEMENT, 'l_return_status: ' || l_return_status);
2815: LogMessage(FND_LOG.LEVEL_STATEMENT, 'l_msg_data: ' || substr(l_msg_data,1,225));
2816:
2817: IF l_return_status <> FND_API.G_RET_STS_SUCCESS THEN
2818:
2819: -- LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'ERROR: AR_RECEIPT_API_PUB.APPLY raised error: ' || substr(l_msg_data,1,225));
2820: FND_MESSAGE.SET_NAME('LNS', 'LNS_APPL_CR_FAIL');
2821: FND_MSG_PUB.Add;

Line 2823: RAISE FND_API.G_EXC_ERROR;

2819: -- LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'ERROR: AR_RECEIPT_API_PUB.APPLY raised error: ' || substr(l_msg_data,1,225));
2820: FND_MESSAGE.SET_NAME('LNS', 'LNS_APPL_CR_FAIL');
2821: FND_MSG_PUB.Add;
2822: LogMessage(FND_LOG.LEVEL_ERROR, FND_MSG_PUB.Get(p_encoded => 'F'));
2823: RAISE FND_API.G_EXC_ERROR;
2824:
2825: ELSE
2826: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Successfully applied cash receipt to trx ' || P_TRX_ID || ' line ' || P_TRX_LINE_ID);
2827: END IF;

Line 2967: p_init_msg_list => FND_API.G_TRUE,

2963:
2964: AR_ADJUST_PUB.Create_Adjustment(
2965: p_api_name => 'AR_ADJUST_PUB',
2966: p_api_version => 1.0,
2967: p_init_msg_list => FND_API.G_TRUE,
2968: p_commit_flag => FND_API.G_FALSE,
2969: p_validation_level => FND_API.G_VALID_LEVEL_FULL,
2970: p_msg_count => l_msg_count,
2971: p_msg_data => l_msg_data,

Line 2968: p_commit_flag => FND_API.G_FALSE,

2964: AR_ADJUST_PUB.Create_Adjustment(
2965: p_api_name => 'AR_ADJUST_PUB',
2966: p_api_version => 1.0,
2967: p_init_msg_list => FND_API.G_TRUE,
2968: p_commit_flag => FND_API.G_FALSE,
2969: p_validation_level => FND_API.G_VALID_LEVEL_FULL,
2970: p_msg_count => l_msg_count,
2971: p_msg_data => l_msg_data,
2972: p_return_status => l_return_status,

Line 2969: p_validation_level => FND_API.G_VALID_LEVEL_FULL,

2965: p_api_name => 'AR_ADJUST_PUB',
2966: p_api_version => 1.0,
2967: p_init_msg_list => FND_API.G_TRUE,
2968: p_commit_flag => FND_API.G_FALSE,
2969: p_validation_level => FND_API.G_VALID_LEVEL_FULL,
2970: p_msg_count => l_msg_count,
2971: p_msg_data => l_msg_data,
2972: p_return_status => l_return_status,
2973: p_adj_rec => l_adj_rec,

Line 2985: IF l_return_status <> FND_API.G_RET_STS_SUCCESS or

2981: LogMessage(FND_LOG.LEVEL_STATEMENT, 'l_return_status: ' || l_return_status);
2982: LogMessage(FND_LOG.LEVEL_STATEMENT, 'l_adj_id: ' || l_adj_id);
2983: LogMessage(FND_LOG.LEVEL_STATEMENT, 'l_adj_num: ' || l_adj_num);
2984:
2985: IF l_return_status <> FND_API.G_RET_STS_SUCCESS or
2986: l_adj_id is null or
2987: l_adj_num is null
2988: THEN
2989: FND_MESSAGE.SET_NAME('LNS', 'LNS_CR_ADJ_FAIL');

Line 2990: if l_return_status = FND_API.G_RET_STS_SUCCESS and l_adj_id is null then

2986: l_adj_id is null or
2987: l_adj_num is null
2988: THEN
2989: FND_MESSAGE.SET_NAME('LNS', 'LNS_CR_ADJ_FAIL');
2990: if l_return_status = FND_API.G_RET_STS_SUCCESS and l_adj_id is null then
2991: FND_MESSAGE.SET_TOKEN('REASON', 'new_adjust_id is null');
2992: elsif l_return_status = FND_API.G_RET_STS_SUCCESS and l_adj_num is null then
2993: FND_MESSAGE.SET_TOKEN('REASON', 'new_adjust_number is null');
2994: else

Line 2992: elsif l_return_status = FND_API.G_RET_STS_SUCCESS and l_adj_num is null then

2988: THEN
2989: FND_MESSAGE.SET_NAME('LNS', 'LNS_CR_ADJ_FAIL');
2990: if l_return_status = FND_API.G_RET_STS_SUCCESS and l_adj_id is null then
2991: FND_MESSAGE.SET_TOKEN('REASON', 'new_adjust_id is null');
2992: elsif l_return_status = FND_API.G_RET_STS_SUCCESS and l_adj_num is null then
2993: FND_MESSAGE.SET_TOKEN('REASON', 'new_adjust_number is null');
2994: else
2995: FND_MESSAGE.SET_TOKEN('REASON', 'unknown');
2996: end if;

Line 3009: RAISE FND_API.G_EXC_ERROR;

3005: LogMessage(FND_LOG.LEVEL_ERROR, 'Error: ' || l_msg);
3006: l_indexNo := l_indexNo + 1;
3007: End Loop;
3008:
3009: RAISE FND_API.G_EXC_ERROR;
3010:
3011: END IF;
3012:
3013: X_ADJ_ID := l_adj_id;

Line 3695: RAISE FND_API.G_EXC_ERROR;

3691:
3692: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Update successfull!');
3693:
3694: else
3695: RAISE FND_API.G_EXC_ERROR;
3696: end if;
3697:
3698: --close context
3699: DBMS_XMLQuery.closeContext(qryCtx);

Line 3712: RAISE FND_API.G_EXC_ERROR;

3708: FND_MSG_PUB.Add;
3709: LogMessage(FND_LOG.LEVEL_ERROR, FND_MSG_PUB.Get(p_encoded => 'F'));
3710: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Failed to generate billing statement');
3711: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'ERROR: ' || sqlerrm);
3712: RAISE FND_API.G_EXC_ERROR;
3713:
3714: END GENERATE_BILLING_STATEMENT_XML;
3715:
3716: -- this function returns available amount to be billed for the specified date

Line 3786: RAISE FND_API.G_EXC_ERROR;

3782: -- FND_MESSAGE.SET_ENCODED('Principal bill amount cannot be greater than ' || l_valid_amount);
3783: FND_MESSAGE.SET_NAME('LNS', 'LNS_INVALID_PRIN_BILL_AMOUNT');
3784: FND_MSG_PUB.Add;
3785: LogMessage(FND_LOG.LEVEL_ERROR, FND_MSG_PUB.Get(p_encoded => 'F'));
3786: RAISE FND_API.G_EXC_ERROR;
3787: end if;
3788:
3789: END;
3790:

Line 3917: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version, l_api_name, G_PKG_NAME) THEN

3913: SAVEPOINT PROCESS_SINGLE_LOAN_PVT;
3914: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Established savepoint');
3915:
3916: -- Standard call to check for call compatibility
3917: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version, l_api_name, G_PKG_NAME) THEN
3918: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
3919: END IF;
3920:
3921: -- Initialize message list if p_init_msg_list is set to TRUE

Line 3918: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;

3914: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Established savepoint');
3915:
3916: -- Standard call to check for call compatibility
3917: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version, l_api_name, G_PKG_NAME) THEN
3918: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
3919: END IF;
3920:
3921: -- Initialize message list if p_init_msg_list is set to TRUE
3922: IF FND_API.To_Boolean(p_init_msg_list) THEN

Line 3922: IF FND_API.To_Boolean(p_init_msg_list) THEN

3918: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
3919: END IF;
3920:
3921: -- Initialize message list if p_init_msg_list is set to TRUE
3922: IF FND_API.To_Boolean(p_init_msg_list) THEN
3923: FND_MSG_PUB.initialize;
3924: END IF;
3925:
3926: -- Initialize API return status to success

Line 3927: l_return_status := FND_API.G_RET_STS_SUCCESS;

3923: FND_MSG_PUB.initialize;
3924: END IF;
3925:
3926: -- Initialize API return status to success
3927: l_return_status := FND_API.G_RET_STS_SUCCESS;
3928:
3929: -- START OF BODY OF API
3930:
3931:

Line 3967: RAISE FND_API.G_EXC_ERROR;

3963: FND_MESSAGE.SET_NAME('LNS', 'LNS_LOAN_MISS_DATA');
3964: FND_MESSAGE.SET_TOKEN('LOAN', P_LOAN_REC.LOAN_NUMBER);
3965: FND_MSG_PUB.Add;
3966: LogMessage(FND_LOG.LEVEL_ERROR, FND_MSG_PUB.Get(p_encoded => 'F'));
3967: RAISE FND_API.G_EXC_ERROR;
3968:
3969: end if;
3970:
3971: /* getting current payment number */

Line 3987: P_INIT_MSG_LIST => FND_API.G_TRUE,

3983: if l_do_billing > 0 then
3984:
3985: LNS_BILLING_BATCH_PUB.PREBILL_SINGLE_LOAN(
3986: P_API_VERSION => 1.0,
3987: P_INIT_MSG_LIST => FND_API.G_TRUE,
3988: P_COMMIT => FND_API.G_FALSE,
3989: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,
3990: P_LOAN_ID => P_LOAN_REC.LOAN_ID,
3991: X_BILLED_YN => l_billed_0th_yn,

Line 3988: P_COMMIT => FND_API.G_FALSE,

3984:
3985: LNS_BILLING_BATCH_PUB.PREBILL_SINGLE_LOAN(
3986: P_API_VERSION => 1.0,
3987: P_INIT_MSG_LIST => FND_API.G_TRUE,
3988: P_COMMIT => FND_API.G_FALSE,
3989: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,
3990: P_LOAN_ID => P_LOAN_REC.LOAN_ID,
3991: X_BILLED_YN => l_billed_0th_yn,
3992: x_return_status => l_return_status,

Line 3989: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,

3985: LNS_BILLING_BATCH_PUB.PREBILL_SINGLE_LOAN(
3986: P_API_VERSION => 1.0,
3987: P_INIT_MSG_LIST => FND_API.G_TRUE,
3988: P_COMMIT => FND_API.G_FALSE,
3989: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,
3990: P_LOAN_ID => P_LOAN_REC.LOAN_ID,
3991: X_BILLED_YN => l_billed_0th_yn,
3992: x_return_status => l_return_status,
3993: x_msg_count => l_msg_count,

Line 3997: RAISE FND_API.G_EXC_ERROR;

3993: x_msg_count => l_msg_count,
3994: x_msg_data => l_msg_data);
3995:
3996: if l_return_status <> 'S' then
3997: RAISE FND_API.G_EXC_ERROR;
3998: end if;
3999:
4000: if l_billed_0th_yn = 'Y' then
4001:

Line 4040: p_init_msg_list => FND_API.G_TRUE,

4036: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Calling lns_financials.getInstallment...');
4037: l_start := sysdate;
4038: lns_financials.getInstallment(
4039: p_api_version => 1.0,
4040: p_init_msg_list => FND_API.G_TRUE,
4041: p_commit => FND_API.G_FALSE,
4042: p_loan_Id => P_LOAN_REC.LOAN_ID,
4043: p_installment_number => P_LOAN_REC.NEXT_PAYMENT_NUMBER,
4044: x_amortization_rec => l_amortization_rec,

Line 4041: p_commit => FND_API.G_FALSE,

4037: l_start := sysdate;
4038: lns_financials.getInstallment(
4039: p_api_version => 1.0,
4040: p_init_msg_list => FND_API.G_TRUE,
4041: p_commit => FND_API.G_FALSE,
4042: p_loan_Id => P_LOAN_REC.LOAN_ID,
4043: p_installment_number => P_LOAN_REC.NEXT_PAYMENT_NUMBER,
4044: x_amortization_rec => l_amortization_rec,
4045: x_fees_tbl => l_fee_tbl,

Line 4058: p_init_msg_list => FND_API.G_TRUE,

4054:
4055: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Calling lns_financials.getOpenInstallment...');
4056: l_start := sysdate;
4057: lns_financials.getOpenInstallment(
4058: p_init_msg_list => FND_API.G_TRUE,
4059: p_loan_Id => P_LOAN_REC.LOAN_ID,
4060: p_installment_number => P_LOAN_REC.NEXT_PAYMENT_NUMBER,
4061: x_amortization_rec => l_amortization_rec,
4062: x_fees_tbl => l_fee_tbl,

Line 4076: RAISE FND_API.G_EXC_ERROR;

4072: LogMessage(FND_LOG.LEVEL_STATEMENT, 'l_return_status: ' || l_return_status);
4073: LogMessage(FND_LOG.LEVEL_STATEMENT, 'l_msg_data: ' || l_msg_data);
4074:
4075: if l_return_status <> 'S' then
4076: RAISE FND_API.G_EXC_ERROR;
4077: end if;
4078:
4079: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Data returned from lns_financials.getInstallment:');
4080: LogMessage(FND_LOG.LEVEL_STATEMENT, 'INSTALLMENT_NUMBER: ' || l_amortization_rec.INSTALLMENT_NUMBER);

Line 4105: RAISE FND_API.G_EXC_ERROR;

4101: FND_MESSAGE.SET_NAME('LNS', 'LNS_BILLING_DISABLED');
4102: FND_MESSAGE.SET_TOKEN('LOAN_NUMBER', p_loan_rec.loan_number);
4103: FND_MSG_PUB.Add;
4104: LogMessage(FND_LOG.LEVEL_UNEXPECTED, FND_MSG_PUB.Get(p_encoded => 'F'));
4105: RAISE FND_API.G_EXC_ERROR;
4106: END IF;
4107:
4108:
4109: /* checking for returned values */

Line 4140: RAISE FND_API.G_EXC_ERROR;

4136: FND_MESSAGE.SET_NAME('LNS', 'LNS_CANT_BILL_ZERO_AMOUNT');
4137: FND_MESSAGE.SET_TOKEN('PROFILE', l_profile_name);
4138: FND_MSG_PUB.Add;
4139: LogMessage(FND_LOG.LEVEL_UNEXPECTED, FND_MSG_PUB.Get(p_encoded => 'F'));
4140: RAISE FND_API.G_EXC_ERROR;
4141: -- return;
4142: end if;
4143:
4144: end if;

Line 4246: RAISE FND_API.G_EXC_ERROR;

4242:
4243: FND_MESSAGE.SET_NAME('LNS', 'LNS_INVALID_FEE_INSTAL');
4244: FND_MSG_PUB.Add;
4245: LogMessage(FND_LOG.LEVEL_ERROR, FND_MSG_PUB.Get(p_encoded => 'F'));
4246: RAISE FND_API.G_EXC_ERROR;
4247:
4248: end if;
4249:
4250: /* updating LNS_FEE_SCHEDULES with billed_flag = Y */

Line 4299: P_INIT_MSG_LIST => FND_API.G_FALSE,

4295: LogMessage(FND_LOG.LEVEL_STATEMENT, 'LAST_BILLED_DATE: ' || l_loan_header_rec.LAST_BILLED_DATE);
4296:
4297: LNS_LOAN_HEADER_PUB.UPDATE_LOAN(P_OBJECT_VERSION_NUMBER => P_LOAN_REC.OBJECT_VERSION_NUMBER,
4298: P_LOAN_HEADER_REC => l_loan_header_rec,
4299: P_INIT_MSG_LIST => FND_API.G_FALSE,
4300: X_RETURN_STATUS => l_return_status,
4301: X_MSG_COUNT => l_msg_count,
4302: X_MSG_DATA => l_msg_data);
4303:

Line 4313: RAISE FND_API.G_EXC_ERROR;

4309: -- LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'ERROR: LNS_LOAN_HEADER_PUB.UPDATE_LOAN returned error: ' || substr(l_msg_data,1,225));
4310: FND_MESSAGE.SET_NAME('LNS', 'LNS_UPD_LOAN_FAIL');
4311: FND_MSG_PUB.Add;
4312: LogMessage(FND_LOG.LEVEL_ERROR, FND_MSG_PUB.Get(p_encoded => 'F'));
4313: RAISE FND_API.G_EXC_ERROR;
4314: END IF;
4315:
4316: STORE_LAST_PAYMENT_NUMBER(P_LOAN_REC.LOAN_ID);
4317:

Line 4348: if P_COMMIT = FND_API.G_TRUE then

4344: amount => dbms_lob.getlength(l_statement_xml)-l_offset,
4345: src_offset => l_offset+1);
4346: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Have copied generated statement to output');
4347:
4348: if P_COMMIT = FND_API.G_TRUE then
4349: COMMIT WORK;
4350: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Commited loan ' || P_LOAN_REC.LOAN_NUMBER);
4351: end if;
4352:

Line 4354: x_return_status := FND_API.G_RET_STS_SUCCESS;

4350: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Commited loan ' || P_LOAN_REC.LOAN_NUMBER);
4351: end if;
4352:
4353: -- END OF BODY OF API
4354: x_return_status := FND_API.G_RET_STS_SUCCESS;
4355:
4356: -- Standard call to get message count and if count is 1, get message info
4357: FND_MSG_PUB.Count_And_Get(
4358: p_encoded => FND_API.G_FALSE,

Line 4358: p_encoded => FND_API.G_FALSE,

4354: x_return_status := FND_API.G_RET_STS_SUCCESS;
4355:
4356: -- Standard call to get message count and if count is 1, get message info
4357: FND_MSG_PUB.Count_And_Get(
4358: p_encoded => FND_API.G_FALSE,
4359: p_count => x_msg_count,
4360: p_data => x_msg_data);
4361:
4362: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Successfully processed loan ' || P_LOAN_REC.LOAN_NUMBER);

Line 4366: WHEN FND_API.G_EXC_ERROR THEN

4362: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Successfully processed loan ' || P_LOAN_REC.LOAN_NUMBER);
4363: LogMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME || '.' || l_api_name || ' -');
4364:
4365: EXCEPTION
4366: WHEN FND_API.G_EXC_ERROR THEN
4367: ROLLBACK TO PROCESS_SINGLE_LOAN_PVT;
4368: x_return_status := FND_API.G_RET_STS_ERROR;
4369: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
4370: LogMessage(FND_LOG.LEVEL_ERROR, 'Rollbacked loan ' || P_LOAN_REC.LOAN_NUMBER);

Line 4368: x_return_status := FND_API.G_RET_STS_ERROR;

4364:
4365: EXCEPTION
4366: WHEN FND_API.G_EXC_ERROR THEN
4367: ROLLBACK TO PROCESS_SINGLE_LOAN_PVT;
4368: x_return_status := FND_API.G_RET_STS_ERROR;
4369: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
4370: LogMessage(FND_LOG.LEVEL_ERROR, 'Rollbacked loan ' || P_LOAN_REC.LOAN_NUMBER);
4371: g_cr_return_status := 'WARNING';
4372:

Line 4383: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN

4379: P_DUE_DATE => P_LOAN_REC.NEXT_PAYMENT_DUE_DATE,
4380: P_ERR_COUNT => x_msg_count,
4381: X_STATEMENT_XML => X_STATEMENT_XML);
4382:
4383: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
4384: ROLLBACK TO PROCESS_SINGLE_LOAN_PVT;
4385: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
4386: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
4387: LogMessage(FND_LOG.LEVEL_ERROR, 'Rollbacked loan ' || P_LOAN_REC.LOAN_NUMBER);

Line 4385: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;

4381: X_STATEMENT_XML => X_STATEMENT_XML);
4382:
4383: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
4384: ROLLBACK TO PROCESS_SINGLE_LOAN_PVT;
4385: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
4386: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
4387: LogMessage(FND_LOG.LEVEL_ERROR, 'Rollbacked loan ' || P_LOAN_REC.LOAN_NUMBER);
4388: g_cr_return_status := 'WARNING';
4389:

Line 4402: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;

4398: X_STATEMENT_XML => X_STATEMENT_XML);
4399:
4400: WHEN OTHERS THEN
4401: ROLLBACK TO PROCESS_SINGLE_LOAN_PVT;
4402: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
4403: IF FND_MSG_PUB.Check_Msg_Level(FND_MSG_PUB.G_MSG_LVL_UNEXP_ERROR)THEN
4404: FND_MSG_PUB.Add_Exc_Msg(G_PKG_NAME, l_api_name);
4405: END IF;
4406: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);

Line 4508: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version, l_api_name, G_PKG_NAME) THEN

4504: SAVEPOINT SINGLE_LOAN_NEXT_DD_PVT;
4505: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Established savepoint');
4506:
4507: -- Standard call to check for call compatibility
4508: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version, l_api_name, G_PKG_NAME) THEN
4509: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
4510: END IF;
4511:
4512: -- Initialize message list if p_init_msg_list is set to TRUE

Line 4509: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;

4505: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Established savepoint');
4506:
4507: -- Standard call to check for call compatibility
4508: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version, l_api_name, G_PKG_NAME) THEN
4509: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
4510: END IF;
4511:
4512: -- Initialize message list if p_init_msg_list is set to TRUE
4513: IF FND_API.To_Boolean(p_init_msg_list) THEN

Line 4513: IF FND_API.To_Boolean(p_init_msg_list) THEN

4509: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
4510: END IF;
4511:
4512: -- Initialize message list if p_init_msg_list is set to TRUE
4513: IF FND_API.To_Boolean(p_init_msg_list) THEN
4514: FND_MSG_PUB.initialize;
4515: END IF;
4516:
4517: -- Initialize API return status to success

Line 4518: l_return_status := FND_API.G_RET_STS_SUCCESS;

4514: FND_MSG_PUB.initialize;
4515: END IF;
4516:
4517: -- Initialize API return status to success
4518: l_return_status := FND_API.G_RET_STS_SUCCESS;
4519:
4520: -- START OF BODY OF API
4521: l_start := sysdate;
4522:

Line 4540: P_INIT_MSG_LIST => FND_API.G_FALSE,

4536:
4537: if l_cur_phase = 'TERM' then
4538: lns_financials.preProcessInstallment(
4539: P_API_VERSION => 1.0,
4540: P_INIT_MSG_LIST => FND_API.G_FALSE,
4541: P_COMMIT => FND_API.G_FALSE,
4542: p_loan_Id => P_LOAN_NEXT_DD_REC.LOAN_ID,
4543: p_installment_number => P_LOAN_NEXT_DD_REC.NEXT_PAYMENT_NUMBER,
4544: X_AMORTIZATION_REC => l_amortization_rec,

Line 4541: P_COMMIT => FND_API.G_FALSE,

4537: if l_cur_phase = 'TERM' then
4538: lns_financials.preProcessInstallment(
4539: P_API_VERSION => 1.0,
4540: P_INIT_MSG_LIST => FND_API.G_FALSE,
4541: P_COMMIT => FND_API.G_FALSE,
4542: p_loan_Id => P_LOAN_NEXT_DD_REC.LOAN_ID,
4543: p_installment_number => P_LOAN_NEXT_DD_REC.NEXT_PAYMENT_NUMBER,
4544: X_AMORTIZATION_REC => l_amortization_rec,
4545: X_RETURN_STATUS => l_return_status,

Line 4551: P_INIT_MSG_LIST => FND_API.G_FALSE,

4547: X_MSG_DATA => l_msg_data);
4548: else
4549: lns_financials.preProcessOpenInstallment(
4550: -- P_API_VERSION => 1.0,
4551: P_INIT_MSG_LIST => FND_API.G_FALSE,
4552: P_COMMIT => FND_API.G_FALSE,
4553: p_loan_Id => P_LOAN_NEXT_DD_REC.LOAN_ID,
4554: p_installment_number => P_LOAN_NEXT_DD_REC.NEXT_PAYMENT_NUMBER,
4555: X_AMORTIZATION_REC => l_amortization_rec,

Line 4552: P_COMMIT => FND_API.G_FALSE,

4548: else
4549: lns_financials.preProcessOpenInstallment(
4550: -- P_API_VERSION => 1.0,
4551: P_INIT_MSG_LIST => FND_API.G_FALSE,
4552: P_COMMIT => FND_API.G_FALSE,
4553: p_loan_Id => P_LOAN_NEXT_DD_REC.LOAN_ID,
4554: p_installment_number => P_LOAN_NEXT_DD_REC.NEXT_PAYMENT_NUMBER,
4555: X_AMORTIZATION_REC => l_amortization_rec,
4556: X_RETURN_STATUS => l_return_status,

Line 4575: -- RAISE FND_API.G_EXC_ERROR;

4571: -- LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'ERROR: Next installment date is unknown.');
4572: FND_MESSAGE.SET_NAME('LNS', 'LNS_NO_INST_DUE_DATE');
4573: FND_MSG_PUB.Add;
4574: LogMessage(FND_LOG.LEVEL_ERROR, FND_MSG_PUB.Get(p_encoded => 'F'));
4575: -- RAISE FND_API.G_EXC_ERROR;
4576:
4577: end if;
4578:
4579: /* Updating loan header */

Line 4588: P_INIT_MSG_LIST => FND_API.G_FALSE,

4584: l_object_version_number := P_LOAN_NEXT_DD_REC.OBJECT_VERSION_NUMBER;
4585:
4586: LNS_LOAN_HEADER_PUB.UPDATE_LOAN(P_OBJECT_VERSION_NUMBER => l_object_version_number,
4587: P_LOAN_HEADER_REC => l_loan_header_rec,
4588: P_INIT_MSG_LIST => FND_API.G_FALSE,
4589: X_RETURN_STATUS => l_return_status,
4590: X_MSG_COUNT => l_msg_count,
4591: X_MSG_DATA => l_msg_data);
4592:

Line 4602: RAISE FND_API.G_EXC_ERROR;

4598: -- LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'ERROR: LNS_LOAN_HEADER_PUB.UPDATE_LOAN returned error: ' || substr(l_msg_data,1,225));
4599: FND_MESSAGE.SET_NAME('LNS', 'LNS_UPD_LOAN_FAIL');
4600: FND_MSG_PUB.Add;
4601: LogMessage(FND_LOG.LEVEL_ERROR, FND_MSG_PUB.Get(p_encoded => 'F'));
4602: RAISE FND_API.G_EXC_ERROR;
4603: END IF;
4604:
4605: /* getting terms version for future update */
4606: open term_version_cur(P_LOAN_NEXT_DD_REC.LOAN_ID);

Line 4625: p_init_msg_list => FND_API.G_FALSE,

4621: LogMessage(FND_LOG.LEVEL_STATEMENT, 'OPEN_NEXT_PAYMENT_DATE: ' || l_term_rec.OPEN_NEXT_PAYMENT_DATE);
4622: end if;
4623:
4624: LNS_TERMS_PUB.update_term(P_OBJECT_VERSION_NUMBER => l_version_number,
4625: p_init_msg_list => FND_API.G_FALSE,
4626: p_loan_term_rec => l_term_rec,
4627: X_RETURN_STATUS => l_return_status,
4628: X_MSG_COUNT => l_msg_count,
4629: X_MSG_DATA => l_msg_data);

Line 4640: RAISE FND_API.G_EXC_ERROR;

4636: -- LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'ERROR: LNS_TERMS_PUB.update_term returned error: ' || substr(l_msg_data,1,225));
4637: FND_MESSAGE.SET_NAME('LNS', 'LNS_UPD_TERM_FAIL');
4638: FND_MSG_PUB.Add;
4639: LogMessage(FND_LOG.LEVEL_ERROR, FND_MSG_PUB.Get(p_encoded => 'F'));
4640: RAISE FND_API.G_EXC_ERROR;
4641: END IF;
4642:
4643: l_end := sysdate;
4644: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Timing: ' || round((l_end - l_start)*86400, 2) || ' sec');

Line 4646: if P_COMMIT = FND_API.G_TRUE then

4642:
4643: l_end := sysdate;
4644: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Timing: ' || round((l_end - l_start)*86400, 2) || ' sec');
4645:
4646: if P_COMMIT = FND_API.G_TRUE then
4647: COMMIT WORK;
4648: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Commited loan ' || P_LOAN_NEXT_DD_REC.LOAN_NUMBER);
4649: end if;
4650:

Line 4652: x_return_status := FND_API.G_RET_STS_SUCCESS;

4648: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Commited loan ' || P_LOAN_NEXT_DD_REC.LOAN_NUMBER);
4649: end if;
4650:
4651: -- END OF BODY OF API
4652: x_return_status := FND_API.G_RET_STS_SUCCESS;
4653:
4654: -- Standard call to get message count and if count is 1, get message info
4655: FND_MSG_PUB.Count_And_Get(
4656: p_encoded => FND_API.G_FALSE,

Line 4656: p_encoded => FND_API.G_FALSE,

4652: x_return_status := FND_API.G_RET_STS_SUCCESS;
4653:
4654: -- Standard call to get message count and if count is 1, get message info
4655: FND_MSG_PUB.Count_And_Get(
4656: p_encoded => FND_API.G_FALSE,
4657: p_count => x_msg_count,
4658: p_data => x_msg_data);
4659:
4660: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Successfully processed loan ' || P_LOAN_NEXT_DD_REC.LOAN_NUMBER);

Line 4664: WHEN FND_API.G_EXC_ERROR THEN

4660: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Successfully processed loan ' || P_LOAN_NEXT_DD_REC.LOAN_NUMBER);
4661: LogMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME || '.' || l_api_name || ' -');
4662:
4663: EXCEPTION
4664: WHEN FND_API.G_EXC_ERROR THEN
4665: ROLLBACK TO SINGLE_LOAN_NEXT_DD_PVT;
4666: x_return_status := FND_API.G_RET_STS_ERROR;
4667: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
4668: LogMessage(FND_LOG.LEVEL_ERROR, 'Rollbacked loan ' || P_LOAN_NEXT_DD_REC.LOAN_NUMBER);

Line 4666: x_return_status := FND_API.G_RET_STS_ERROR;

4662:
4663: EXCEPTION
4664: WHEN FND_API.G_EXC_ERROR THEN
4665: ROLLBACK TO SINGLE_LOAN_NEXT_DD_PVT;
4666: x_return_status := FND_API.G_RET_STS_ERROR;
4667: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
4668: LogMessage(FND_LOG.LEVEL_ERROR, 'Rollbacked loan ' || P_LOAN_NEXT_DD_REC.LOAN_NUMBER);
4669: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
4670: ROLLBACK TO SINGLE_LOAN_NEXT_DD_PVT;

Line 4669: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN

4665: ROLLBACK TO SINGLE_LOAN_NEXT_DD_PVT;
4666: x_return_status := FND_API.G_RET_STS_ERROR;
4667: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
4668: LogMessage(FND_LOG.LEVEL_ERROR, 'Rollbacked loan ' || P_LOAN_NEXT_DD_REC.LOAN_NUMBER);
4669: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
4670: ROLLBACK TO SINGLE_LOAN_NEXT_DD_PVT;
4671: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
4672: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
4673: LogMessage(FND_LOG.LEVEL_ERROR, 'Rollbacked loan ' || P_LOAN_NEXT_DD_REC.LOAN_NUMBER);

Line 4671: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;

4667: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
4668: LogMessage(FND_LOG.LEVEL_ERROR, 'Rollbacked loan ' || P_LOAN_NEXT_DD_REC.LOAN_NUMBER);
4669: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
4670: ROLLBACK TO SINGLE_LOAN_NEXT_DD_PVT;
4671: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
4672: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
4673: LogMessage(FND_LOG.LEVEL_ERROR, 'Rollbacked loan ' || P_LOAN_NEXT_DD_REC.LOAN_NUMBER);
4674: WHEN OTHERS THEN
4675: ROLLBACK TO SINGLE_LOAN_NEXT_DD_PVT;

Line 4676: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;

4672: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
4673: LogMessage(FND_LOG.LEVEL_ERROR, 'Rollbacked loan ' || P_LOAN_NEXT_DD_REC.LOAN_NUMBER);
4674: WHEN OTHERS THEN
4675: ROLLBACK TO SINGLE_LOAN_NEXT_DD_PVT;
4676: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
4677: IF FND_MSG_PUB.Check_Msg_Level(FND_MSG_PUB.G_MSG_LVL_UNEXP_ERROR)THEN
4678: FND_MSG_PUB.Add_Exc_Msg(G_PKG_NAME, l_api_name);
4679: END IF;
4680: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);

Line 4748: P_INIT_MSG_LIST => FND_API.G_TRUE,

4744: LogMessage(FND_LOG.LEVEL_UNEXPECTED, '<<--------Processing paid off loans...-------->>');
4745:
4746: PROCESS_PAID_LOANS(
4747: P_API_VERSION => 1.0,
4748: P_INIT_MSG_LIST => FND_API.G_TRUE,
4749: P_COMMIT => FND_API.G_TRUE,
4750: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,
4751: P_LOAN_ID => null,
4752: P_PAYOFF_DATE => sysdate,

Line 4749: P_COMMIT => FND_API.G_TRUE,

4745:
4746: PROCESS_PAID_LOANS(
4747: P_API_VERSION => 1.0,
4748: P_INIT_MSG_LIST => FND_API.G_TRUE,
4749: P_COMMIT => FND_API.G_TRUE,
4750: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,
4751: P_LOAN_ID => null,
4752: P_PAYOFF_DATE => sysdate,
4753: X_RETURN_STATUS => RETCODE,

Line 4750: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,

4746: PROCESS_PAID_LOANS(
4747: P_API_VERSION => 1.0,
4748: P_INIT_MSG_LIST => FND_API.G_TRUE,
4749: P_COMMIT => FND_API.G_TRUE,
4750: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,
4751: P_LOAN_ID => null,
4752: P_PAYOFF_DATE => sysdate,
4753: X_RETURN_STATUS => RETCODE,
4754: X_MSG_COUNT => l_msg_count,

Line 4764: P_INIT_MSG_LIST => FND_API.G_TRUE,

4760: LogMessage(FND_LOG.LEVEL_UNEXPECTED, '<<--------Processing paid off loans that must be reactivated...-------->>');
4761:
4762: REACTIVATE_PAID_LOANS(
4763: P_API_VERSION => 1.0,
4764: P_INIT_MSG_LIST => FND_API.G_TRUE,
4765: P_COMMIT => FND_API.G_TRUE,
4766: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,
4767: X_RETURN_STATUS => RETCODE,
4768: X_MSG_COUNT => l_msg_count,

Line 4765: P_COMMIT => FND_API.G_TRUE,

4761:
4762: REACTIVATE_PAID_LOANS(
4763: P_API_VERSION => 1.0,
4764: P_INIT_MSG_LIST => FND_API.G_TRUE,
4765: P_COMMIT => FND_API.G_TRUE,
4766: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,
4767: X_RETURN_STATUS => RETCODE,
4768: X_MSG_COUNT => l_msg_count,
4769: X_MSG_DATA => ERRBUF);

Line 4766: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,

4762: REACTIVATE_PAID_LOANS(
4763: P_API_VERSION => 1.0,
4764: P_INIT_MSG_LIST => FND_API.G_TRUE,
4765: P_COMMIT => FND_API.G_TRUE,
4766: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,
4767: X_RETURN_STATUS => RETCODE,
4768: X_MSG_COUNT => l_msg_count,
4769: X_MSG_DATA => ERRBUF);
4770:

Line 4776: P_INIT_MSG_LIST => FND_API.G_TRUE,

4772: LogMessage(FND_LOG.LEVEL_UNEXPECTED, '<<--------Recalculating due date for past due loans...-------->>');
4773:
4774: CALC_PAST_DUE_LOANS_NEXT_DD(
4775: P_API_VERSION => 1.0,
4776: P_INIT_MSG_LIST => FND_API.G_TRUE,
4777: P_COMMIT => FND_API.G_TRUE,
4778: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,
4779: X_RETURN_STATUS => RETCODE,
4780: X_MSG_COUNT => l_msg_count,

Line 4777: P_COMMIT => FND_API.G_TRUE,

4773:
4774: CALC_PAST_DUE_LOANS_NEXT_DD(
4775: P_API_VERSION => 1.0,
4776: P_INIT_MSG_LIST => FND_API.G_TRUE,
4777: P_COMMIT => FND_API.G_TRUE,
4778: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,
4779: X_RETURN_STATUS => RETCODE,
4780: X_MSG_COUNT => l_msg_count,
4781: X_MSG_DATA => ERRBUF);

Line 4778: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,

4774: CALC_PAST_DUE_LOANS_NEXT_DD(
4775: P_API_VERSION => 1.0,
4776: P_INIT_MSG_LIST => FND_API.G_TRUE,
4777: P_COMMIT => FND_API.G_TRUE,
4778: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,
4779: X_RETURN_STATUS => RETCODE,
4780: X_MSG_COUNT => l_msg_count,
4781: X_MSG_DATA => ERRBUF);
4782:

Line 4789: P_INIT_MSG_LIST => FND_API.G_TRUE,

4785:
4786: /* bill loans and stores all last billed statements in g_last_all_statements */
4787: BILL_LOANS(
4788: P_API_VERSION => 1.0,
4789: P_INIT_MSG_LIST => FND_API.G_TRUE,
4790: P_COMMIT => FND_API.G_TRUE,
4791: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,
4792: P_TYPE_ID => TYPE_ID,
4793: P_PRODUCT_ID => PRODUCT_ID,

Line 4790: P_COMMIT => FND_API.G_TRUE,

4786: /* bill loans and stores all last billed statements in g_last_all_statements */
4787: BILL_LOANS(
4788: P_API_VERSION => 1.0,
4789: P_INIT_MSG_LIST => FND_API.G_TRUE,
4790: P_COMMIT => FND_API.G_TRUE,
4791: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,
4792: P_TYPE_ID => TYPE_ID,
4793: P_PRODUCT_ID => PRODUCT_ID,
4794: P_BORROWER_ID => BORROWER_ID,

Line 4791: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,

4787: BILL_LOANS(
4788: P_API_VERSION => 1.0,
4789: P_INIT_MSG_LIST => FND_API.G_TRUE,
4790: P_COMMIT => FND_API.G_TRUE,
4791: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,
4792: P_TYPE_ID => TYPE_ID,
4793: P_PRODUCT_ID => PRODUCT_ID,
4794: P_BORROWER_ID => BORROWER_ID,
4795: P_LOAN_ID => LOAN_ID,

Line 4879: P_INIT_MSG_LIST => FND_API.G_TRUE,

4875: LogMessage(FND_LOG.LEVEL_UNEXPECTED, '<<--------Reversing a loans last payment...-------->>');
4876:
4877: REVERSE_LAST_AMORTIZATION(
4878: P_API_VERSION => 1.0,
4879: P_INIT_MSG_LIST => FND_API.G_TRUE,
4880: P_COMMIT => FND_API.G_TRUE,
4881: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,
4882: P_LOAN_ID => LOAN_ID,
4883: P_REBILL_FLAG => REBILL_FLAG,

Line 4880: P_COMMIT => FND_API.G_TRUE,

4876:
4877: REVERSE_LAST_AMORTIZATION(
4878: P_API_VERSION => 1.0,
4879: P_INIT_MSG_LIST => FND_API.G_TRUE,
4880: P_COMMIT => FND_API.G_TRUE,
4881: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,
4882: P_LOAN_ID => LOAN_ID,
4883: P_REBILL_FLAG => REBILL_FLAG,
4884: X_RETURN_STATUS => RETCODE,

Line 4881: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,

4877: REVERSE_LAST_AMORTIZATION(
4878: P_API_VERSION => 1.0,
4879: P_INIT_MSG_LIST => FND_API.G_TRUE,
4880: P_COMMIT => FND_API.G_TRUE,
4881: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,
4882: P_LOAN_ID => LOAN_ID,
4883: P_REBILL_FLAG => REBILL_FLAG,
4884: X_RETURN_STATUS => RETCODE,
4885: X_MSG_COUNT => l_msg_count,

Line 4951: P_INIT_MSG_LIST => FND_API.G_TRUE,

4947: LogMessage(FND_LOG.LEVEL_UNEXPECTED, ' ');
4948:
4949: ADJUST_ORIGINAL_RECEIVABLE(
4950: P_API_VERSION => 1.0,
4951: P_INIT_MSG_LIST => FND_API.G_TRUE,
4952: P_COMMIT => FND_API.G_TRUE,
4953: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,
4954: P_LOAN_ID => LOAN_ID,
4955: X_RETURN_STATUS => RETCODE,

Line 4952: P_COMMIT => FND_API.G_TRUE,

4948:
4949: ADJUST_ORIGINAL_RECEIVABLE(
4950: P_API_VERSION => 1.0,
4951: P_INIT_MSG_LIST => FND_API.G_TRUE,
4952: P_COMMIT => FND_API.G_TRUE,
4953: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,
4954: P_LOAN_ID => LOAN_ID,
4955: X_RETURN_STATUS => RETCODE,
4956: X_MSG_COUNT => l_msg_count,

Line 4953: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,

4949: ADJUST_ORIGINAL_RECEIVABLE(
4950: P_API_VERSION => 1.0,
4951: P_INIT_MSG_LIST => FND_API.G_TRUE,
4952: P_COMMIT => FND_API.G_TRUE,
4953: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,
4954: P_LOAN_ID => LOAN_ID,
4955: X_RETURN_STATUS => RETCODE,
4956: X_MSG_COUNT => l_msg_count,
4957: X_MSG_DATA => ERRBUF);

Line 5051: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version, l_api_name, G_PKG_NAME) THEN

5047: SAVEPOINT BILL_LOANS_EXT_PVT;
5048: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Savepoint is established');
5049:
5050: -- Standard call to check for call compatibility
5051: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version, l_api_name, G_PKG_NAME) THEN
5052: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
5053: END IF;
5054:
5055: -- Initialize message list if p_init_msg_list is set to TRUE

Line 5052: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;

5048: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Savepoint is established');
5049:
5050: -- Standard call to check for call compatibility
5051: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version, l_api_name, G_PKG_NAME) THEN
5052: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
5053: END IF;
5054:
5055: -- Initialize message list if p_init_msg_list is set to TRUE
5056: IF FND_API.To_Boolean(p_init_msg_list) THEN

Line 5056: IF FND_API.To_Boolean(p_init_msg_list) THEN

5052: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
5053: END IF;
5054:
5055: -- Initialize message list if p_init_msg_list is set to TRUE
5056: IF FND_API.To_Boolean(p_init_msg_list) THEN
5057: FND_MSG_PUB.initialize;
5058: END IF;
5059:
5060: -- Initialize API return status to success

Line 5061: l_return_status := FND_API.G_RET_STS_SUCCESS;

5057: FND_MSG_PUB.initialize;
5058: END IF;
5059:
5060: -- Initialize API return status to success
5061: l_return_status := FND_API.G_RET_STS_SUCCESS;
5062:
5063: -- START OF BODY OF API
5064:
5065: l_loans_to_bill_tbl := P_LOANS_TO_BILL_TBL;

Line 5084: P_INIT_MSG_LIST => FND_API.G_TRUE,

5080:
5081: l_start := sysdate;
5082: BILL_SINGLE_LOAN(
5083: P_API_VERSION => 1.0,
5084: P_INIT_MSG_LIST => FND_API.G_TRUE,
5085: P_COMMIT => FND_API.G_FALSE,
5086: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,
5087: P_LOAN_REC => l_loans_to_bill_tbl(l_Count1),
5088: X_STATEMENT_XML => l_single_statement_xml,

Line 5085: P_COMMIT => FND_API.G_FALSE,

5081: l_start := sysdate;
5082: BILL_SINGLE_LOAN(
5083: P_API_VERSION => 1.0,
5084: P_INIT_MSG_LIST => FND_API.G_TRUE,
5085: P_COMMIT => FND_API.G_FALSE,
5086: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,
5087: P_LOAN_REC => l_loans_to_bill_tbl(l_Count1),
5088: X_STATEMENT_XML => l_single_statement_xml,
5089: X_RETURN_STATUS => l_return_status,

Line 5086: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,

5082: BILL_SINGLE_LOAN(
5083: P_API_VERSION => 1.0,
5084: P_INIT_MSG_LIST => FND_API.G_TRUE,
5085: P_COMMIT => FND_API.G_FALSE,
5086: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,
5087: P_LOAN_REC => l_loans_to_bill_tbl(l_Count1),
5088: X_STATEMENT_XML => l_single_statement_xml,
5089: X_RETURN_STATUS => l_return_status,
5090: X_MSG_COUNT => l_msg_count,

Line 5107: P_INIT_MSG_LIST => FND_API.G_TRUE,

5103: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Performing loan forgiveness adjustment for loan ' || l_loans_to_bill_tbl(l_Count1).LOAN_ID || '...');
5104: l_start1 := sysdate;
5105: FORGIVENESS_ADJUSTMENT(
5106: P_API_VERSION => 1.0,
5107: P_INIT_MSG_LIST => FND_API.G_TRUE,
5108: P_COMMIT => FND_API.G_FALSE,
5109: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,
5110: P_LOAN_ID => l_loans_to_bill_tbl(l_Count1).LOAN_ID,
5111: X_RETURN_STATUS => l_return_status,

Line 5108: P_COMMIT => FND_API.G_FALSE,

5104: l_start1 := sysdate;
5105: FORGIVENESS_ADJUSTMENT(
5106: P_API_VERSION => 1.0,
5107: P_INIT_MSG_LIST => FND_API.G_TRUE,
5108: P_COMMIT => FND_API.G_FALSE,
5109: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,
5110: P_LOAN_ID => l_loans_to_bill_tbl(l_Count1).LOAN_ID,
5111: X_RETURN_STATUS => l_return_status,
5112: X_MSG_COUNT => l_msg_count,

Line 5109: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,

5105: FORGIVENESS_ADJUSTMENT(
5106: P_API_VERSION => 1.0,
5107: P_INIT_MSG_LIST => FND_API.G_TRUE,
5108: P_COMMIT => FND_API.G_FALSE,
5109: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,
5110: P_LOAN_ID => l_loans_to_bill_tbl(l_Count1).LOAN_ID,
5111: X_RETURN_STATUS => l_return_status,
5112: X_MSG_COUNT => l_msg_count,
5113: X_MSG_DATA => l_msg_data);

Line 5126: RAISE FND_API.G_EXC_ERROR;

5122: -- LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'ERROR: Failed to perform forgiveness adjustment for loan ' || l_loans_to_bill_tbl(l_Count1).LOAN_NUMBER);
5123: FND_MESSAGE.SET_NAME('LNS', 'LNS_FORGIVENESS_FAIL');
5124: FND_MSG_PUB.Add;
5125: LogMessage(FND_LOG.LEVEL_UNEXPECTED, FND_MSG_PUB.Get(p_encoded => 'F'));
5126: RAISE FND_API.G_EXC_ERROR;
5127: END IF;
5128:
5129: else
5130: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Will not perform loan forgiveness adjustment for loan ' || l_loans_to_bill_tbl(l_Count1).LOAN_ID);

Line 5135: if P_COMMIT = FND_API.G_TRUE then

5131: end if;
5132:
5133: dbms_lob.Append(g_last_all_statements, l_single_statement_xml);
5134:
5135: if P_COMMIT = FND_API.G_TRUE then
5136: COMMIT WORK;
5137: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Commited loan ' || l_loans_to_bill_tbl(l_Count1).LOAN_NUMBER);
5138: end if;
5139:

Line 5149: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;

5145:
5146: EXCEPTION
5147: WHEN OTHERS THEN
5148: ROLLBACK TO BILL_LOANS_EXT_PVT1;
5149: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
5150: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
5151: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Rollbacked loan ' || l_loans_to_bill_tbl(l_Count1).LOAN_NUMBER);
5152: g_cr_return_status := 'WARNING';
5153:

Line 5184: RAISE FND_API.G_EXC_ERROR;

5180: end if;
5181:
5182: IF l_return_status <> 'S' THEN
5183: -- Above the error statements are created and now raise the error
5184: RAISE FND_API.G_EXC_ERROR;
5185: END IF;
5186:
5187: LogMessage(FND_LOG.LEVEL_UNEXPECTED, '______________');
5188: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Total processed ' || l_loans_to_bill_tbl.COUNT || ' loan(s)');

Line 5190: if P_COMMIT = FND_API.G_TRUE then

5186:
5187: LogMessage(FND_LOG.LEVEL_UNEXPECTED, '______________');
5188: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Total processed ' || l_loans_to_bill_tbl.COUNT || ' loan(s)');
5189:
5190: if P_COMMIT = FND_API.G_TRUE then
5191: COMMIT WORK;
5192: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Commited loans');
5193: end if;
5194:

Line 5196: x_return_status := FND_API.G_RET_STS_SUCCESS;

5192: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Commited loans');
5193: end if;
5194:
5195: -- END OF BODY OF API
5196: x_return_status := FND_API.G_RET_STS_SUCCESS;
5197:
5198: -- Standard call to get message count and if count is 1, get message info
5199: FND_MSG_PUB.Count_And_Get(
5200: p_encoded => FND_API.G_FALSE,

Line 5200: p_encoded => FND_API.G_FALSE,

5196: x_return_status := FND_API.G_RET_STS_SUCCESS;
5197:
5198: -- Standard call to get message count and if count is 1, get message info
5199: FND_MSG_PUB.Count_And_Get(
5200: p_encoded => FND_API.G_FALSE,
5201: p_count => x_msg_count,
5202: p_data => x_msg_data);
5203:
5204: LogMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME || '.' || l_api_name || ' -');

Line 5207: WHEN FND_API.G_EXC_ERROR THEN

5203:
5204: LogMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME || '.' || l_api_name || ' -');
5205:
5206: EXCEPTION
5207: WHEN FND_API.G_EXC_ERROR THEN
5208: ROLLBACK TO BILL_LOANS_EXT_PVT;
5209: x_return_status := FND_API.G_RET_STS_ERROR;
5210: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
5211: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Rollbacked loans');

Line 5209: x_return_status := FND_API.G_RET_STS_ERROR;

5205:
5206: EXCEPTION
5207: WHEN FND_API.G_EXC_ERROR THEN
5208: ROLLBACK TO BILL_LOANS_EXT_PVT;
5209: x_return_status := FND_API.G_RET_STS_ERROR;
5210: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
5211: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Rollbacked loans');
5212: g_cr_return_status := 'ERROR';
5213: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN

Line 5213: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN

5209: x_return_status := FND_API.G_RET_STS_ERROR;
5210: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
5211: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Rollbacked loans');
5212: g_cr_return_status := 'ERROR';
5213: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
5214: ROLLBACK TO BILL_LOANS_EXT_PVT;
5215: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
5216: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
5217: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Rollbacked loans');

Line 5215: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;

5211: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Rollbacked loans');
5212: g_cr_return_status := 'ERROR';
5213: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
5214: ROLLBACK TO BILL_LOANS_EXT_PVT;
5215: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
5216: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
5217: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Rollbacked loans');
5218: g_cr_return_status := 'ERROR';
5219: WHEN OTHERS THEN

Line 5221: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;

5217: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Rollbacked loans');
5218: g_cr_return_status := 'ERROR';
5219: WHEN OTHERS THEN
5220: ROLLBACK TO BILL_LOANS_EXT_PVT;
5221: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
5222: IF FND_MSG_PUB.Check_Msg_Level(FND_MSG_PUB.G_MSG_LVL_UNEXP_ERROR)THEN
5223: FND_MSG_PUB.Add_Exc_Msg(G_PKG_NAME, l_api_name);
5224: END IF;
5225: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);

Line 5375: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version, l_api_name, G_PKG_NAME) THEN

5371: SAVEPOINT BILL_LOANS_PVT;
5372: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Savepoint is established');
5373:
5374: -- Standard call to check for call compatibility
5375: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version, l_api_name, G_PKG_NAME) THEN
5376: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
5377: END IF;
5378:
5379: -- Initialize message list if p_init_msg_list is set to TRUE

Line 5376: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;

5372: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Savepoint is established');
5373:
5374: -- Standard call to check for call compatibility
5375: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version, l_api_name, G_PKG_NAME) THEN
5376: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
5377: END IF;
5378:
5379: -- Initialize message list if p_init_msg_list is set to TRUE
5380: IF FND_API.To_Boolean(p_init_msg_list) THEN

Line 5380: IF FND_API.To_Boolean(p_init_msg_list) THEN

5376: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
5377: END IF;
5378:
5379: -- Initialize message list if p_init_msg_list is set to TRUE
5380: IF FND_API.To_Boolean(p_init_msg_list) THEN
5381: FND_MSG_PUB.initialize;
5382: END IF;
5383:
5384: -- Initialize API return status to success

Line 5385: l_return_status := FND_API.G_RET_STS_SUCCESS;

5381: FND_MSG_PUB.initialize;
5382: END IF;
5383:
5384: -- Initialize API return status to success
5385: l_return_status := FND_API.G_RET_STS_SUCCESS;
5386:
5387: -- START OF BODY OF API
5388:
5389: /* init all_statements clob */

Line 5424: RAISE FND_API.G_EXC_ERROR;

5420: -- LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'ERROR: At least one of the days must be set.');
5421: FND_MESSAGE.SET_NAME('LNS', 'LNS_NO_BILLING_INP_PAR');
5422: FND_MSG_PUB.Add;
5423: LogMessage(FND_LOG.LEVEL_ERROR, FND_MSG_PUB.Get(p_encoded => 'F'));
5424: RAISE FND_API.G_EXC_ERROR;
5425: else
5426: l_to_date := g_days_to_bill_before_dd;
5427: LogMessage(FND_LOG.LEVEL_PROCEDURE, 'To Days/Date: ' || l_to_date || GET_BILLING_DATE(l_to_date));
5428: end if;

Line 5549: P_INIT_MSG_LIST => FND_API.G_FALSE,

5545:
5546: l_start := sysdate;
5547: BILL_SINGLE_LOAN(
5548: P_API_VERSION => 1.0,
5549: P_INIT_MSG_LIST => FND_API.G_FALSE,
5550: P_COMMIT => P_COMMIT,
5551: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,
5552: P_LOAN_REC => l_loans_to_bill_tbl(l_Count1),
5553: X_STATEMENT_XML => l_single_statement_xml,

Line 5551: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,

5547: BILL_SINGLE_LOAN(
5548: P_API_VERSION => 1.0,
5549: P_INIT_MSG_LIST => FND_API.G_FALSE,
5550: P_COMMIT => P_COMMIT,
5551: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,
5552: P_LOAN_REC => l_loans_to_bill_tbl(l_Count1),
5553: X_STATEMENT_XML => l_single_statement_xml,
5554: X_RETURN_STATUS => l_return_status,
5555: X_MSG_COUNT => l_msg_count,

Line 5574: P_INIT_MSG_LIST => FND_API.G_FALSE,

5570: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Performing loan forgiveness adjustment for loan ' || l_loans_to_bill_tbl(l_Count1).LOAN_ID || '...');
5571: l_start1 := sysdate;
5572: FORGIVENESS_ADJUSTMENT(
5573: P_API_VERSION => 1.0,
5574: P_INIT_MSG_LIST => FND_API.G_FALSE,
5575: P_COMMIT => P_COMMIT,
5576: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,
5577: P_LOAN_ID => l_loans_to_bill_tbl(l_Count1).LOAN_ID,
5578: X_RETURN_STATUS => l_return_status,

Line 5576: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,

5572: FORGIVENESS_ADJUSTMENT(
5573: P_API_VERSION => 1.0,
5574: P_INIT_MSG_LIST => FND_API.G_FALSE,
5575: P_COMMIT => P_COMMIT,
5576: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,
5577: P_LOAN_ID => l_loans_to_bill_tbl(l_Count1).LOAN_ID,
5578: X_RETURN_STATUS => l_return_status,
5579: X_MSG_COUNT => l_msg_count,
5580: X_MSG_DATA => l_msg_data);

Line 5623: if P_COMMIT = FND_API.G_TRUE then

5619:
5620: LogMessage(FND_LOG.LEVEL_PROCEDURE, '______________');
5621: LogMessage(FND_LOG.LEVEL_PROCEDURE, 'Total processed ' || (l_Count1-1) || ' loan(s)');
5622:
5623: if P_COMMIT = FND_API.G_TRUE then
5624: COMMIT WORK;
5625: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Commited loans');
5626: end if;
5627:

Line 5629: x_return_status := FND_API.G_RET_STS_SUCCESS;

5625: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Commited loans');
5626: end if;
5627:
5628: -- END OF BODY OF API
5629: x_return_status := FND_API.G_RET_STS_SUCCESS;
5630:
5631: -- Standard call to get message count and if count is 1, get message info
5632: FND_MSG_PUB.Count_And_Get(
5633: p_encoded => FND_API.G_FALSE,

Line 5633: p_encoded => FND_API.G_FALSE,

5629: x_return_status := FND_API.G_RET_STS_SUCCESS;
5630:
5631: -- Standard call to get message count and if count is 1, get message info
5632: FND_MSG_PUB.Count_And_Get(
5633: p_encoded => FND_API.G_FALSE,
5634: p_count => x_msg_count,
5635: p_data => x_msg_data);
5636:
5637: LogMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME || '.' || l_api_name || ' -');

Line 5640: WHEN FND_API.G_EXC_ERROR THEN

5636:
5637: LogMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME || '.' || l_api_name || ' -');
5638:
5639: EXCEPTION
5640: WHEN FND_API.G_EXC_ERROR THEN
5641: ROLLBACK TO BILL_LOANS_PVT;
5642: x_return_status := FND_API.G_RET_STS_ERROR;
5643: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
5644: LogMessage(FND_LOG.LEVEL_ERROR, 'Rollbacked loans');

Line 5642: x_return_status := FND_API.G_RET_STS_ERROR;

5638:
5639: EXCEPTION
5640: WHEN FND_API.G_EXC_ERROR THEN
5641: ROLLBACK TO BILL_LOANS_PVT;
5642: x_return_status := FND_API.G_RET_STS_ERROR;
5643: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
5644: LogMessage(FND_LOG.LEVEL_ERROR, 'Rollbacked loans');
5645: g_cr_return_status := 'ERROR';
5646: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN

Line 5646: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN

5642: x_return_status := FND_API.G_RET_STS_ERROR;
5643: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
5644: LogMessage(FND_LOG.LEVEL_ERROR, 'Rollbacked loans');
5645: g_cr_return_status := 'ERROR';
5646: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
5647: ROLLBACK TO BILL_LOANS_PVT;
5648: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
5649: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
5650: LogMessage(FND_LOG.LEVEL_ERROR, 'Rollbacked loans');

Line 5648: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;

5644: LogMessage(FND_LOG.LEVEL_ERROR, 'Rollbacked loans');
5645: g_cr_return_status := 'ERROR';
5646: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
5647: ROLLBACK TO BILL_LOANS_PVT;
5648: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
5649: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
5650: LogMessage(FND_LOG.LEVEL_ERROR, 'Rollbacked loans');
5651: g_cr_return_status := 'ERROR';
5652: WHEN OTHERS THEN

Line 5654: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;

5650: LogMessage(FND_LOG.LEVEL_ERROR, 'Rollbacked loans');
5651: g_cr_return_status := 'ERROR';
5652: WHEN OTHERS THEN
5653: ROLLBACK TO BILL_LOANS_PVT;
5654: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
5655: IF FND_MSG_PUB.Check_Msg_Level(FND_MSG_PUB.G_MSG_LVL_UNEXP_ERROR)THEN
5656: FND_MSG_PUB.Add_Exc_Msg(G_PKG_NAME, l_api_name);
5657: END IF;
5658: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);

Line 5756: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version, l_api_name, G_PKG_NAME) THEN

5752: SAVEPOINT LOANS_NEXT_DD_PVT;
5753: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Established savepoint');
5754:
5755: -- Standard call to check for call compatibility
5756: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version, l_api_name, G_PKG_NAME) THEN
5757: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
5758: END IF;
5759:
5760: -- Initialize message list if p_init_msg_list is set to TRUE

Line 5757: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;

5753: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Established savepoint');
5754:
5755: -- Standard call to check for call compatibility
5756: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version, l_api_name, G_PKG_NAME) THEN
5757: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
5758: END IF;
5759:
5760: -- Initialize message list if p_init_msg_list is set to TRUE
5761: IF FND_API.To_Boolean(p_init_msg_list) THEN

Line 5761: IF FND_API.To_Boolean(p_init_msg_list) THEN

5757: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
5758: END IF;
5759:
5760: -- Initialize message list if p_init_msg_list is set to TRUE
5761: IF FND_API.To_Boolean(p_init_msg_list) THEN
5762: FND_MSG_PUB.initialize;
5763: END IF;
5764:
5765: -- Initialize API return status to success

Line 5766: l_return_status := FND_API.G_RET_STS_SUCCESS;

5762: FND_MSG_PUB.initialize;
5763: END IF;
5764:
5765: -- Initialize API return status to success
5766: l_return_status := FND_API.G_RET_STS_SUCCESS;
5767:
5768: -- START OF BODY OF API
5769:
5770: init;

Line 5795: P_INIT_MSG_LIST => FND_API.G_FALSE,

5791: l_Count1 := l_Count1+1;
5792:
5793: CALC_SINGLE_LOAN_NEXT_DD(
5794: P_API_VERSION => 1.0,
5795: P_INIT_MSG_LIST => FND_API.G_FALSE,
5796: P_COMMIT => P_COMMIT,
5797: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,
5798: P_LOAN_NEXT_DD_REC => l_loans_next_dd_rec,
5799: X_RETURN_STATUS => l_return_status,

Line 5797: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,

5793: CALC_SINGLE_LOAN_NEXT_DD(
5794: P_API_VERSION => 1.0,
5795: P_INIT_MSG_LIST => FND_API.G_FALSE,
5796: P_COMMIT => P_COMMIT,
5797: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,
5798: P_LOAN_NEXT_DD_REC => l_loans_next_dd_rec,
5799: X_RETURN_STATUS => l_return_status,
5800: X_MSG_COUNT => l_msg_count,
5801: X_MSG_DATA => l_msg_data);

Line 5812: if P_COMMIT = FND_API.G_TRUE then

5808: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Total processed ' || (l_Count1-1) || ' loan(s)');
5809: l_end := sysdate;
5810: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'All Recalc Timing: ' || round((l_end - l_start)*86400, 2) || ' sec');
5811:
5812: if P_COMMIT = FND_API.G_TRUE then
5813: COMMIT WORK;
5814: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Commited loans');
5815: end if;
5816:

Line 5818: x_return_status := FND_API.G_RET_STS_SUCCESS;

5814: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Commited loans');
5815: end if;
5816:
5817: -- END OF BODY OF API
5818: x_return_status := FND_API.G_RET_STS_SUCCESS;
5819:
5820: -- Standard call to get message count and if count is 1, get message info
5821: FND_MSG_PUB.Count_And_Get(
5822: p_encoded => FND_API.G_FALSE,

Line 5822: p_encoded => FND_API.G_FALSE,

5818: x_return_status := FND_API.G_RET_STS_SUCCESS;
5819:
5820: -- Standard call to get message count and if count is 1, get message info
5821: FND_MSG_PUB.Count_And_Get(
5822: p_encoded => FND_API.G_FALSE,
5823: p_count => x_msg_count,
5824: p_data => x_msg_data);
5825:
5826: LogMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME || '.' || l_api_name || ' -');

Line 5829: WHEN FND_API.G_EXC_ERROR THEN

5825:
5826: LogMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME || '.' || l_api_name || ' -');
5827:
5828: EXCEPTION
5829: WHEN FND_API.G_EXC_ERROR THEN
5830: ROLLBACK TO LOANS_NEXT_DD_PVT;
5831: x_return_status := FND_API.G_RET_STS_ERROR;
5832: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
5833: LogMessage(FND_LOG.LEVEL_ERROR, 'Rollbacked loans');

Line 5831: x_return_status := FND_API.G_RET_STS_ERROR;

5827:
5828: EXCEPTION
5829: WHEN FND_API.G_EXC_ERROR THEN
5830: ROLLBACK TO LOANS_NEXT_DD_PVT;
5831: x_return_status := FND_API.G_RET_STS_ERROR;
5832: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
5833: LogMessage(FND_LOG.LEVEL_ERROR, 'Rollbacked loans');
5834: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
5835: ROLLBACK TO LOANS_NEXT_DD_PVT;

Line 5834: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN

5830: ROLLBACK TO LOANS_NEXT_DD_PVT;
5831: x_return_status := FND_API.G_RET_STS_ERROR;
5832: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
5833: LogMessage(FND_LOG.LEVEL_ERROR, 'Rollbacked loans');
5834: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
5835: ROLLBACK TO LOANS_NEXT_DD_PVT;
5836: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
5837: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
5838: LogMessage(FND_LOG.LEVEL_ERROR, 'Rollbacked loans');

Line 5836: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;

5832: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
5833: LogMessage(FND_LOG.LEVEL_ERROR, 'Rollbacked loans');
5834: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
5835: ROLLBACK TO LOANS_NEXT_DD_PVT;
5836: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
5837: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
5838: LogMessage(FND_LOG.LEVEL_ERROR, 'Rollbacked loans');
5839: WHEN OTHERS THEN
5840: ROLLBACK TO LOANS_NEXT_DD_PVT;

Line 5841: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;

5837: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
5838: LogMessage(FND_LOG.LEVEL_ERROR, 'Rollbacked loans');
5839: WHEN OTHERS THEN
5840: ROLLBACK TO LOANS_NEXT_DD_PVT;
5841: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
5842: IF FND_MSG_PUB.Check_Msg_Level(FND_MSG_PUB.G_MSG_LVL_UNEXP_ERROR)THEN
5843: FND_MSG_PUB.Add_Exc_Msg(G_PKG_NAME, l_api_name);
5844: END IF;
5845: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);

Line 5995: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version, l_api_name, G_PKG_NAME) THEN

5991: SAVEPOINT REVERSE_LAST_AMORTIZATION;
5992: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Savepoint is established');
5993:
5994: -- Standard call to check for call compatibility
5995: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version, l_api_name, G_PKG_NAME) THEN
5996: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
5997: END IF;
5998:
5999: -- Initialize message list if p_init_msg_list is set to TRUE

Line 5996: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;

5992: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Savepoint is established');
5993:
5994: -- Standard call to check for call compatibility
5995: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version, l_api_name, G_PKG_NAME) THEN
5996: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
5997: END IF;
5998:
5999: -- Initialize message list if p_init_msg_list is set to TRUE
6000: IF FND_API.To_Boolean(p_init_msg_list) THEN

Line 6000: IF FND_API.To_Boolean(p_init_msg_list) THEN

5996: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
5997: END IF;
5998:
5999: -- Initialize message list if p_init_msg_list is set to TRUE
6000: IF FND_API.To_Boolean(p_init_msg_list) THEN
6001: FND_MSG_PUB.initialize;
6002: END IF;
6003:
6004: -- Initialize API return status to success

Line 6005: l_return_status := FND_API.G_RET_STS_SUCCESS;

6001: FND_MSG_PUB.initialize;
6002: END IF;
6003:
6004: -- Initialize API return status to success
6005: l_return_status := FND_API.G_RET_STS_SUCCESS;
6006:
6007: -- START OF BODY OF API
6008:
6009: init;

Line 6032: RAISE FND_API.G_EXC_ERROR;

6028: -- LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'ERROR: Loan must be set.');
6029: FND_MESSAGE.SET_NAME('LNS', 'LNS_NO_LOAN');
6030: FND_MSG_PUB.Add;
6031: LogMessage(FND_LOG.LEVEL_ERROR, FND_MSG_PUB.Get(p_encoded => 'F'));
6032: RAISE FND_API.G_EXC_ERROR;
6033:
6034: end if;
6035:
6036: /* quering for last loan amortization record */

Line 6114: RAISE FND_API.G_EXC_ERROR;

6110: /*
6111: FND_MESSAGE.SET_NAME('LNS', 'LNS_NO_TRX_LINES_TO_REV');
6112: FND_MSG_PUB.Add;
6113: LogMessage(FND_LOG.LEVEL_ERROR, FND_MSG_PUB.Get(p_encoded => 'F'));
6114: RAISE FND_API.G_EXC_ERROR;
6115: */
6116: else
6117:
6118: /* Create credit memos */

Line 6156: P_INIT_MSG_LIST => FND_API.G_FALSE,

6152: l_INSTALLMENT_REC.LOCK_INT := 'Y';
6153:
6154: LNS_CUSTOM_PUB.addMissingInstallment(
6155: P_API_VERSION => 1.0,
6156: P_INIT_MSG_LIST => FND_API.G_FALSE,
6157: P_COMMIT => FND_API.G_FALSE,
6158: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,
6159: P_INSTALLMENT_REC => l_INSTALLMENT_REC,
6160: X_RETURN_STATUS => l_return_status,

Line 6157: P_COMMIT => FND_API.G_FALSE,

6153:
6154: LNS_CUSTOM_PUB.addMissingInstallment(
6155: P_API_VERSION => 1.0,
6156: P_INIT_MSG_LIST => FND_API.G_FALSE,
6157: P_COMMIT => FND_API.G_FALSE,
6158: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,
6159: P_INSTALLMENT_REC => l_INSTALLMENT_REC,
6160: X_RETURN_STATUS => l_return_status,
6161: X_MSG_COUNT => l_msg_count,

Line 6158: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,

6154: LNS_CUSTOM_PUB.addMissingInstallment(
6155: P_API_VERSION => 1.0,
6156: P_INIT_MSG_LIST => FND_API.G_FALSE,
6157: P_COMMIT => FND_API.G_FALSE,
6158: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,
6159: P_INSTALLMENT_REC => l_INSTALLMENT_REC,
6160: X_RETURN_STATUS => l_return_status,
6161: X_MSG_COUNT => l_msg_count,
6162: X_MSG_DATA => l_msg_data);

Line 6180: P_INIT_MSG_LIST => FND_API.G_FALSE,

6176: l_loans_next_dd_rec.CUSTOM_PAYMENTS_FLAG := l_custom_payment_flag;
6177:
6178: CALC_SINGLE_LOAN_NEXT_DD(
6179: P_API_VERSION => 1.0,
6180: P_INIT_MSG_LIST => FND_API.G_FALSE,
6181: P_COMMIT => P_COMMIT,
6182: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,
6183: P_LOAN_NEXT_DD_REC => l_loans_next_dd_rec,
6184: X_RETURN_STATUS => l_return_status,

Line 6182: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,

6178: CALC_SINGLE_LOAN_NEXT_DD(
6179: P_API_VERSION => 1.0,
6180: P_INIT_MSG_LIST => FND_API.G_FALSE,
6181: P_COMMIT => P_COMMIT,
6182: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,
6183: P_LOAN_NEXT_DD_REC => l_loans_next_dd_rec,
6184: X_RETURN_STATUS => l_return_status,
6185: X_MSG_COUNT => l_msg_count,
6186: X_MSG_DATA => l_msg_data);

Line 6196: RAISE FND_API.G_EXC_ERROR;

6192: -- LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'ERROR: Failed to calculate next payment due date.');
6193: FND_MESSAGE.SET_NAME('LNS', 'LNS_CALC_NEXT_DUE_FAIL');
6194: FND_MSG_PUB.Add;
6195: LogMessage(FND_LOG.LEVEL_ERROR, FND_MSG_PUB.Get(p_encoded => 'F'));
6196: RAISE FND_API.G_EXC_ERROR;
6197: END IF;
6198:
6199: STORE_LAST_PAYMENT_NUMBER(P_LOAN_ID);
6200:

Line 6201: if P_COMMIT = FND_API.G_TRUE then

6197: END IF;
6198:
6199: STORE_LAST_PAYMENT_NUMBER(P_LOAN_ID);
6200:
6201: if P_COMMIT = FND_API.G_TRUE then
6202: COMMIT WORK;
6203: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Commited loan');
6204: end if;
6205:

Line 6213: p_init_msg_list => FND_API.G_TRUE,

6209: if P_REBILL_FLAG = 'Y' then
6210:
6211: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Reprocessing Fees for loan ' || l_loan_number || ' payment number ' || l_LAST_PAYMENT_NUMBER);
6212: LNS_FEE_ENGINE.reprocessFees(
6213: p_init_msg_list => FND_API.G_TRUE,
6214: p_commit => FND_API.G_TRUE,
6215: p_loan_id => P_LOAN_ID,
6216: p_installment_number => l_LAST_PAYMENT_NUMBER,
6217: p_phase => 'TERM', -- At present change it as 'TERM' which is null

Line 6214: p_commit => FND_API.G_TRUE,

6210:
6211: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Reprocessing Fees for loan ' || l_loan_number || ' payment number ' || l_LAST_PAYMENT_NUMBER);
6212: LNS_FEE_ENGINE.reprocessFees(
6213: p_init_msg_list => FND_API.G_TRUE,
6214: p_commit => FND_API.G_TRUE,
6215: p_loan_id => P_LOAN_ID,
6216: p_installment_number => l_LAST_PAYMENT_NUMBER,
6217: p_phase => 'TERM', -- At present change it as 'TERM' which is null
6218: x_return_status => l_return_status,

Line 6226: RAISE FND_API.G_EXC_ERROR;

6222: IF l_return_status = 'S' THEN
6223: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Successfully reprocessed fees.');
6224: ELSE
6225: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Failed to reprocess fees.');
6226: RAISE FND_API.G_EXC_ERROR;
6227: END IF;
6228:
6229: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Starting billing for loan ' || l_loan_number);
6230:

Line 6233: P_INIT_MSG_LIST => FND_API.G_TRUE,

6229: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Starting billing for loan ' || l_loan_number);
6230:
6231: BILL_LOANS(
6232: P_API_VERSION => 1.0,
6233: P_INIT_MSG_LIST => FND_API.G_TRUE,
6234: P_COMMIT => FND_API.G_TRUE,
6235: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,
6236: P_TYPE_ID => null,
6237: P_PRODUCT_ID => null,

Line 6234: P_COMMIT => FND_API.G_TRUE,

6230:
6231: BILL_LOANS(
6232: P_API_VERSION => 1.0,
6233: P_INIT_MSG_LIST => FND_API.G_TRUE,
6234: P_COMMIT => FND_API.G_TRUE,
6235: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,
6236: P_TYPE_ID => null,
6237: P_PRODUCT_ID => null,
6238: P_BORROWER_ID => null,

Line 6235: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,

6231: BILL_LOANS(
6232: P_API_VERSION => 1.0,
6233: P_INIT_MSG_LIST => FND_API.G_TRUE,
6234: P_COMMIT => FND_API.G_TRUE,
6235: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,
6236: P_TYPE_ID => null,
6237: P_PRODUCT_ID => null,
6238: P_BORROWER_ID => null,
6239: P_LOAN_ID => P_LOAN_ID,

Line 6259: x_return_status := FND_API.G_RET_STS_SUCCESS;

6255:
6256: end if;
6257:
6258: -- END OF BODY OF API
6259: x_return_status := FND_API.G_RET_STS_SUCCESS;
6260:
6261: -- Standard call to get message count and if count is 1, get message info
6262: FND_MSG_PUB.Count_And_Get(
6263: p_encoded => FND_API.G_FALSE,

Line 6263: p_encoded => FND_API.G_FALSE,

6259: x_return_status := FND_API.G_RET_STS_SUCCESS;
6260:
6261: -- Standard call to get message count and if count is 1, get message info
6262: FND_MSG_PUB.Count_And_Get(
6263: p_encoded => FND_API.G_FALSE,
6264: p_count => x_msg_count,
6265: p_data => x_msg_data);
6266:
6267: LogMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME || '.' || l_api_name || ' -');

Line 6270: WHEN FND_API.G_EXC_ERROR THEN

6266:
6267: LogMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME || '.' || l_api_name || ' -');
6268:
6269: EXCEPTION
6270: WHEN FND_API.G_EXC_ERROR THEN
6271: ROLLBACK TO REVERSE_LAST_AMORTIZATION;
6272: x_return_status := FND_API.G_RET_STS_ERROR;
6273: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
6274: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Rollbacked loan');

Line 6272: x_return_status := FND_API.G_RET_STS_ERROR;

6268:
6269: EXCEPTION
6270: WHEN FND_API.G_EXC_ERROR THEN
6271: ROLLBACK TO REVERSE_LAST_AMORTIZATION;
6272: x_return_status := FND_API.G_RET_STS_ERROR;
6273: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
6274: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Rollbacked loan');
6275: g_cr_return_status := 'ERROR';
6276: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN

Line 6276: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN

6272: x_return_status := FND_API.G_RET_STS_ERROR;
6273: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
6274: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Rollbacked loan');
6275: g_cr_return_status := 'ERROR';
6276: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
6277: ROLLBACK TO REVERSE_LAST_AMORTIZATION;
6278: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
6279: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
6280: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Rollbacked loan');

Line 6278: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;

6274: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Rollbacked loan');
6275: g_cr_return_status := 'ERROR';
6276: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
6277: ROLLBACK TO REVERSE_LAST_AMORTIZATION;
6278: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
6279: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
6280: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Rollbacked loan');
6281: g_cr_return_status := 'ERROR';
6282: WHEN OTHERS THEN

Line 6284: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;

6280: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Rollbacked loan');
6281: g_cr_return_status := 'ERROR';
6282: WHEN OTHERS THEN
6283: ROLLBACK TO REVERSE_LAST_AMORTIZATION;
6284: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
6285: IF FND_MSG_PUB.Check_Msg_Level(FND_MSG_PUB.G_MSG_LVL_UNEXP_ERROR)THEN
6286: FND_MSG_PUB.Add_Exc_Msg(G_PKG_NAME, l_api_name);
6287: END IF;
6288: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);

Line 6418: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version, l_api_name, G_PKG_NAME) THEN

6414: SAVEPOINT REVERSE_LAST_AMORTIZATION;
6415: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Savepoint is established');
6416:
6417: -- Standard call to check for call compatibility
6418: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version, l_api_name, G_PKG_NAME) THEN
6419: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
6420: END IF;
6421:
6422: -- Initialize message list if p_init_msg_list is set to TRUE

Line 6419: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;

6415: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Savepoint is established');
6416:
6417: -- Standard call to check for call compatibility
6418: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version, l_api_name, G_PKG_NAME) THEN
6419: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
6420: END IF;
6421:
6422: -- Initialize message list if p_init_msg_list is set to TRUE
6423: IF FND_API.To_Boolean(p_init_msg_list) THEN

Line 6423: IF FND_API.To_Boolean(p_init_msg_list) THEN

6419: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
6420: END IF;
6421:
6422: -- Initialize message list if p_init_msg_list is set to TRUE
6423: IF FND_API.To_Boolean(p_init_msg_list) THEN
6424: FND_MSG_PUB.initialize;
6425: END IF;
6426:
6427: -- Initialize API return status to success

Line 6428: l_return_status := FND_API.G_RET_STS_SUCCESS;

6424: FND_MSG_PUB.initialize;
6425: END IF;
6426:
6427: -- Initialize API return status to success
6428: l_return_status := FND_API.G_RET_STS_SUCCESS;
6429:
6430: -- START OF BODY OF API
6431:
6432: init;

Line 6450: RAISE FND_API.G_EXC_ERROR;

6446: -- LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'ERROR: Loan must be set.');
6447: FND_MESSAGE.SET_NAME('LNS', 'LNS_NO_LOAN');
6448: FND_MSG_PUB.Add;
6449: LogMessage(FND_LOG.LEVEL_ERROR, FND_MSG_PUB.Get(p_encoded => 'F'));
6450: RAISE FND_API.G_EXC_ERROR;
6451:
6452: end if;
6453:
6454: if P_LINE_TYPE is null then

Line 6458: RAISE FND_API.G_EXC_ERROR;

6454: if P_LINE_TYPE is null then
6455: FND_MESSAGE.SET_NAME('LNS', 'LNS_NO_LINE_TYPE');
6456: FND_MSG_PUB.Add;
6457: LogMessage(FND_LOG.LEVEL_ERROR, FND_MSG_PUB.Get(p_encoded => 'F'));
6458: RAISE FND_API.G_EXC_ERROR;
6459: end if;
6460:
6461: /* quering for last loan amortization record */
6462: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Querying for last amortization record in LNS_AMORTIZATION_SCHEDS:');

Line 6527: RAISE FND_API.G_EXC_ERROR;

6523:
6524: FND_MESSAGE.SET_NAME('LNS', 'LNS_NO_TRX_LINES_TO_REV');
6525: FND_MSG_PUB.Add;
6526: LogMessage(FND_LOG.LEVEL_ERROR, FND_MSG_PUB.Get(p_encoded => 'F'));
6527: RAISE FND_API.G_EXC_ERROR;
6528:
6529: end if;
6530:
6531: /* Create credit memos */

Line 6534: if P_COMMIT = FND_API.G_TRUE then

6530:
6531: /* Create credit memos */
6532: CREATE_AR_CM(l_reverse_tbl);
6533:
6534: if P_COMMIT = FND_API.G_TRUE then
6535: COMMIT WORK;
6536: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Commited loan');
6537: end if;
6538:

Line 6542: x_return_status := FND_API.G_RET_STS_SUCCESS;

6538:
6539: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Successfully credit loan ' || l_loan_number);
6540:
6541: -- END OF BODY OF API
6542: x_return_status := FND_API.G_RET_STS_SUCCESS;
6543:
6544: -- Standard call to get message count and if count is 1, get message info
6545: FND_MSG_PUB.Count_And_Get(
6546: p_encoded => FND_API.G_FALSE,

Line 6546: p_encoded => FND_API.G_FALSE,

6542: x_return_status := FND_API.G_RET_STS_SUCCESS;
6543:
6544: -- Standard call to get message count and if count is 1, get message info
6545: FND_MSG_PUB.Count_And_Get(
6546: p_encoded => FND_API.G_FALSE,
6547: p_count => x_msg_count,
6548: p_data => x_msg_data);
6549:
6550: LogMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME || '.' || l_api_name || ' -');

Line 6553: WHEN FND_API.G_EXC_ERROR THEN

6549:
6550: LogMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME || '.' || l_api_name || ' -');
6551:
6552: EXCEPTION
6553: WHEN FND_API.G_EXC_ERROR THEN
6554: ROLLBACK TO REVERSE_LAST_AMORTIZATION;
6555: x_return_status := FND_API.G_RET_STS_ERROR;
6556: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
6557: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Rollbacked loan');

Line 6555: x_return_status := FND_API.G_RET_STS_ERROR;

6551:
6552: EXCEPTION
6553: WHEN FND_API.G_EXC_ERROR THEN
6554: ROLLBACK TO REVERSE_LAST_AMORTIZATION;
6555: x_return_status := FND_API.G_RET_STS_ERROR;
6556: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
6557: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Rollbacked loan');
6558: g_cr_return_status := 'ERROR';
6559: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN

Line 6559: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN

6555: x_return_status := FND_API.G_RET_STS_ERROR;
6556: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
6557: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Rollbacked loan');
6558: g_cr_return_status := 'ERROR';
6559: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
6560: ROLLBACK TO REVERSE_LAST_AMORTIZATION;
6561: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
6562: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
6563: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Rollbacked loan');

Line 6561: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;

6557: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Rollbacked loan');
6558: g_cr_return_status := 'ERROR';
6559: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
6560: ROLLBACK TO REVERSE_LAST_AMORTIZATION;
6561: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
6562: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
6563: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Rollbacked loan');
6564: g_cr_return_status := 'ERROR';
6565: WHEN OTHERS THEN

Line 6567: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;

6563: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Rollbacked loan');
6564: g_cr_return_status := 'ERROR';
6565: WHEN OTHERS THEN
6566: ROLLBACK TO REVERSE_LAST_AMORTIZATION;
6567: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
6568: IF FND_MSG_PUB.Check_Msg_Level(FND_MSG_PUB.G_MSG_LVL_UNEXP_ERROR)THEN
6569: FND_MSG_PUB.Add_Exc_Msg(G_PKG_NAME, l_api_name);
6570: END IF;
6571: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);

Line 6698: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version, l_api_name, G_PKG_NAME) THEN

6694: SAVEPOINT CREATE_SINGLE_OFFCYCLE_BILL;
6695: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Savepoint is established');
6696:
6697: -- Standard call to check for call compatibility
6698: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version, l_api_name, G_PKG_NAME) THEN
6699: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
6700: END IF;
6701:
6702: -- Initialize message list if p_init_msg_list is set to TRUE

Line 6699: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;

6695: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Savepoint is established');
6696:
6697: -- Standard call to check for call compatibility
6698: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version, l_api_name, G_PKG_NAME) THEN
6699: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
6700: END IF;
6701:
6702: -- Initialize message list if p_init_msg_list is set to TRUE
6703: IF FND_API.To_Boolean(p_init_msg_list) THEN

Line 6703: IF FND_API.To_Boolean(p_init_msg_list) THEN

6699: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
6700: END IF;
6701:
6702: -- Initialize message list if p_init_msg_list is set to TRUE
6703: IF FND_API.To_Boolean(p_init_msg_list) THEN
6704: FND_MSG_PUB.initialize;
6705: END IF;
6706:
6707: -- Initialize API return status to success

Line 6708: l_return_status := FND_API.G_RET_STS_SUCCESS;

6704: FND_MSG_PUB.initialize;
6705: END IF;
6706:
6707: -- Initialize API return status to success
6708: l_return_status := FND_API.G_RET_STS_SUCCESS;
6709:
6710: -- START OF BODY OF API
6711:
6712: init;

Line 6726: RAISE FND_API.G_EXC_ERROR;

6722: -- LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'ERROR: Loan ID is not set.');
6723: FND_MESSAGE.SET_NAME('LNS', 'LNS_MAN_BILL_NO_LOAN');
6724: FND_MSG_PUB.Add;
6725: LogMessage(FND_LOG.LEVEL_UNEXPECTED, FND_MSG_PUB.Get(p_encoded => 'F'));
6726: RAISE FND_API.G_EXC_ERROR;
6727: end if;
6728:
6729: if P_BILL_HEADER_REC.ASSOC_PAYMENT_NUM is null then
6730: -- LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'ERROR: Associated Payment Number is not set.');

Line 6734: RAISE FND_API.G_EXC_ERROR;

6730: -- LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'ERROR: Associated Payment Number is not set.');
6731: FND_MESSAGE.SET_NAME('LNS', 'LNS_MAN_BILL_NO_NUM');
6732: FND_MSG_PUB.Add;
6733: LogMessage(FND_LOG.LEVEL_UNEXPECTED, FND_MSG_PUB.Get(p_encoded => 'F'));
6734: RAISE FND_API.G_EXC_ERROR;
6735: end if;
6736:
6737: if P_BILL_HEADER_REC.DUE_DATE is null then
6738: -- LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'ERROR: Bill Due Date is not set.');

Line 6742: RAISE FND_API.G_EXC_ERROR;

6738: -- LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'ERROR: Bill Due Date is not set.');
6739: FND_MESSAGE.SET_NAME('LNS', 'LNS_MAN_BILL_NO_DUE');
6740: FND_MSG_PUB.Add;
6741: LogMessage(FND_LOG.LEVEL_UNEXPECTED, FND_MSG_PUB.Get(p_encoded => 'F'));
6742: RAISE FND_API.G_EXC_ERROR;
6743: end if;
6744:
6745: if l_lines_tbl.count = 0 then
6746: -- LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'ERROR: No lines found for header ' || P_BILL_HEADER_REC.HEADER_ID);

Line 6751: RAISE FND_API.G_EXC_ERROR;

6747: FND_MESSAGE.SET_NAME('LNS', 'LNS_MAN_BILL_NO_LINES');
6748: FND_MESSAGE.SET_TOKEN('HEADER', P_BILL_HEADER_REC.HEADER_ID);
6749: FND_MSG_PUB.Add;
6750: LogMessage(FND_LOG.LEVEL_UNEXPECTED, FND_MSG_PUB.Get(p_encoded => 'F'));
6751: RAISE FND_API.G_EXC_ERROR;
6752: end if;
6753:
6754: /* init amounts */
6755: l_loan_rec.NEXT_PRINCIPAL_AMOUNT := 0;

Line 6781: RAISE FND_API.G_EXC_ERROR;

6777: FND_MESSAGE.SET_NAME('LNS', 'LNS_MAN_BILL_NO_LINE_AMOUNT');
6778: FND_MESSAGE.SET_TOKEN('LINE', l_lines_tbl(l_Count).LINE_ID);
6779: FND_MSG_PUB.Add;
6780: LogMessage(FND_LOG.LEVEL_UNEXPECTED, FND_MSG_PUB.Get(p_encoded => 'F'));
6781: RAISE FND_API.G_EXC_ERROR;
6782: end if;
6783:
6784: if l_lines_tbl(l_Count).LINE_TYPE is null then
6785: -- LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'ERROR: Line type for line ' || l_lines_tbl(l_Count).LINE_ID || ' is not set.');

Line 6790: RAISE FND_API.G_EXC_ERROR;

6786: FND_MESSAGE.SET_NAME('LNS', 'LNS_MAN_BILL_NO_LINE_TYPE');
6787: FND_MESSAGE.SET_TOKEN('LINE', l_lines_tbl(l_Count).LINE_ID);
6788: FND_MSG_PUB.Add;
6789: LogMessage(FND_LOG.LEVEL_UNEXPECTED, FND_MSG_PUB.Get(p_encoded => 'F'));
6790: RAISE FND_API.G_EXC_ERROR;
6791: end if;
6792: /*
6793: if l_lines_tbl(l_Count).LINE_DESC is null then
6794: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'ERROR: Line description for line ' || l_lines_tbl(l_Count).LINE_ID || ' is not set.');

Line 6795: RAISE FND_API.G_EXC_ERROR;

6791: end if;
6792: /*
6793: if l_lines_tbl(l_Count).LINE_DESC is null then
6794: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'ERROR: Line description for line ' || l_lines_tbl(l_Count).LINE_ID || ' is not set.');
6795: RAISE FND_API.G_EXC_ERROR;
6796: end if;
6797: */
6798: /* Suming amounts */
6799: if l_lines_tbl(l_Count).LINE_TYPE = 'PRIN' then

Line 6845: RAISE FND_API.G_EXC_ERROR;

6841: FND_MESSAGE.SET_TOKEN('LOAN',P_BILL_HEADER_REC.LOAN_ID);
6842: FND_MESSAGE.SET_TOKEN('INST', P_BILL_HEADER_REC.ASSOC_PAYMENT_NUM);
6843: FND_MSG_PUB.Add;
6844: LogMessage(FND_LOG.LEVEL_UNEXPECTED, FND_MSG_PUB.Get(p_encoded => 'F'));
6845: RAISE FND_API.G_EXC_ERROR;
6846: end if;
6847:
6848: close loan_cur;
6849:

Line 6916: P_INIT_MSG_LIST => FND_API.G_TRUE,

6912:
6913: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Performing loan forgiveness adjustment...');
6914: FORGIVENESS_ADJUSTMENT(
6915: P_API_VERSION => 1.0,
6916: P_INIT_MSG_LIST => FND_API.G_TRUE,
6917: P_COMMIT => FND_API.G_FALSE,
6918: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,
6919: P_LOAN_ID => l_loan_rec.LOAN_ID,
6920: X_RETURN_STATUS => l_return_status,

Line 6917: P_COMMIT => FND_API.G_FALSE,

6913: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Performing loan forgiveness adjustment...');
6914: FORGIVENESS_ADJUSTMENT(
6915: P_API_VERSION => 1.0,
6916: P_INIT_MSG_LIST => FND_API.G_TRUE,
6917: P_COMMIT => FND_API.G_FALSE,
6918: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,
6919: P_LOAN_ID => l_loan_rec.LOAN_ID,
6920: X_RETURN_STATUS => l_return_status,
6921: X_MSG_COUNT => l_msg_count,

Line 6918: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,

6914: FORGIVENESS_ADJUSTMENT(
6915: P_API_VERSION => 1.0,
6916: P_INIT_MSG_LIST => FND_API.G_TRUE,
6917: P_COMMIT => FND_API.G_FALSE,
6918: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,
6919: P_LOAN_ID => l_loan_rec.LOAN_ID,
6920: X_RETURN_STATUS => l_return_status,
6921: X_MSG_COUNT => l_msg_count,
6922: X_MSG_DATA => l_msg_data);

Line 6931: RAISE FND_API.G_EXC_ERROR;

6927: --LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'ERROR: Failed to perform forgiveness adjustment');
6928: FND_MESSAGE.SET_NAME('LNS', 'LNS_FORGIVENESS_FAIL');
6929: FND_MSG_PUB.Add;
6930: LogMessage(FND_LOG.LEVEL_UNEXPECTED, FND_MSG_PUB.Get(p_encoded => 'F'));
6931: RAISE FND_API.G_EXC_ERROR;
6932: END IF;
6933:
6934: else
6935: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Will not perform loan forgiveness adjustment');

Line 6938: if P_COMMIT = FND_API.G_TRUE then

6934: else
6935: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Will not perform loan forgiveness adjustment');
6936: end if;
6937:
6938: if P_COMMIT = FND_API.G_TRUE then
6939: COMMIT WORK;
6940: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Commited');
6941: end if;
6942:

Line 6962: x_return_status := FND_API.G_RET_STS_SUCCESS;

6958:
6959: END LOOP;
6960:
6961: -- END OF BODY OF API
6962: x_return_status := FND_API.G_RET_STS_SUCCESS;
6963:
6964: -- Standard call to get message count and if count is 1, get message info
6965: FND_MSG_PUB.Count_And_Get(
6966: p_encoded => FND_API.G_FALSE,

Line 6966: p_encoded => FND_API.G_FALSE,

6962: x_return_status := FND_API.G_RET_STS_SUCCESS;
6963:
6964: -- Standard call to get message count and if count is 1, get message info
6965: FND_MSG_PUB.Count_And_Get(
6966: p_encoded => FND_API.G_FALSE,
6967: p_count => x_msg_count,
6968: p_data => x_msg_data);
6969:
6970: LogMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME || '.' || l_api_name || ' -');

Line 6973: WHEN FND_API.G_EXC_ERROR THEN

6969:
6970: LogMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME || '.' || l_api_name || ' -');
6971:
6972: EXCEPTION
6973: WHEN FND_API.G_EXC_ERROR THEN
6974: ROLLBACK TO CREATE_SINGLE_OFFCYCLE_BILL;
6975: x_return_status := FND_API.G_RET_STS_ERROR;
6976: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
6977: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Rollbacked');

Line 6975: x_return_status := FND_API.G_RET_STS_ERROR;

6971:
6972: EXCEPTION
6973: WHEN FND_API.G_EXC_ERROR THEN
6974: ROLLBACK TO CREATE_SINGLE_OFFCYCLE_BILL;
6975: x_return_status := FND_API.G_RET_STS_ERROR;
6976: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
6977: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Rollbacked');
6978: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
6979: ROLLBACK TO CREATE_SINGLE_OFFCYCLE_BILL;

Line 6978: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN

6974: ROLLBACK TO CREATE_SINGLE_OFFCYCLE_BILL;
6975: x_return_status := FND_API.G_RET_STS_ERROR;
6976: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
6977: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Rollbacked');
6978: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
6979: ROLLBACK TO CREATE_SINGLE_OFFCYCLE_BILL;
6980: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
6981: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
6982: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Rollbacked');

Line 6980: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;

6976: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
6977: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Rollbacked');
6978: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
6979: ROLLBACK TO CREATE_SINGLE_OFFCYCLE_BILL;
6980: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
6981: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
6982: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Rollbacked');
6983: WHEN OTHERS THEN
6984: ROLLBACK TO CREATE_SINGLE_OFFCYCLE_BILL;

Line 6985: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;

6981: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
6982: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Rollbacked');
6983: WHEN OTHERS THEN
6984: ROLLBACK TO CREATE_SINGLE_OFFCYCLE_BILL;
6985: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
6986: IF FND_MSG_PUB.Check_Msg_Level(FND_MSG_PUB.G_MSG_LVL_UNEXP_ERROR)THEN
6987: FND_MSG_PUB.Add_Exc_Msg(G_PKG_NAME, l_api_name);
6988: END IF;
6989: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);

Line 7066: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version, l_api_name, G_PKG_NAME) THEN

7062: SAVEPOINT CREATE_OFFCYCLE_BILLS;
7063: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Savepoint is established');
7064:
7065: -- Standard call to check for call compatibility
7066: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version, l_api_name, G_PKG_NAME) THEN
7067: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
7068: END IF;
7069:
7070: -- Initialize message list if p_init_msg_list is set to TRUE

Line 7067: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;

7063: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Savepoint is established');
7064:
7065: -- Standard call to check for call compatibility
7066: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version, l_api_name, G_PKG_NAME) THEN
7067: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
7068: END IF;
7069:
7070: -- Initialize message list if p_init_msg_list is set to TRUE
7071: IF FND_API.To_Boolean(p_init_msg_list) THEN

Line 7071: IF FND_API.To_Boolean(p_init_msg_list) THEN

7067: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
7068: END IF;
7069:
7070: -- Initialize message list if p_init_msg_list is set to TRUE
7071: IF FND_API.To_Boolean(p_init_msg_list) THEN
7072: FND_MSG_PUB.initialize;
7073: END IF;
7074:
7075: -- Initialize API return status to success

Line 7076: l_return_status := FND_API.G_RET_STS_SUCCESS;

7072: FND_MSG_PUB.initialize;
7073: END IF;
7074:
7075: -- Initialize API return status to success
7076: l_return_status := FND_API.G_RET_STS_SUCCESS;
7077:
7078: -- START OF BODY OF API
7079: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Creating OFFCYCLE bills...');
7080:

Line 7089: RAISE FND_API.G_EXC_ERROR;

7085: -- LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'ERROR: Header ID is not set.');
7086: FND_MESSAGE.SET_NAME('LNS', 'LNS_MAN_BILL_NO_HEADER');
7087: FND_MSG_PUB.Add;
7088: LogMessage(FND_LOG.LEVEL_UNEXPECTED, FND_MSG_PUB.Get(p_encoded => 'F'));
7089: RAISE FND_API.G_EXC_ERROR;
7090: end if;
7091:
7092: /* Init lines table */
7093: l_Count2 := 0;

Line 7105: RAISE FND_API.G_EXC_ERROR;

7101: FND_MESSAGE.SET_NAME('LNS', 'LNS_MAN_BILL_NO_LINE_HEADER');
7102: FND_MESSAGE.SET_TOKEN('LINE', P_BILL_LINES_TBL(l_Count1).LINE_ID);
7103: FND_MSG_PUB.Add;
7104: LogMessage(FND_LOG.LEVEL_ERROR, FND_MSG_PUB.Get(p_encoded => 'F'));
7105: RAISE FND_API.G_EXC_ERROR;
7106: end if;
7107:
7108: /* Adding current line record to lines table of current header */
7109: if P_BILL_HEADERS_TBL(l_Count).HEADER_ID = P_BILL_LINES_TBL(l_Count1).HEADER_ID then

Line 7119: P_INIT_MSG_LIST => FND_API.G_TRUE,

7115:
7116: /* Create a single offcycle bill */
7117: CREATE_SINGLE_OFFCYCLE_BILL(
7118: P_API_VERSION => 1.0,
7119: P_INIT_MSG_LIST => FND_API.G_TRUE,
7120: P_COMMIT => FND_API.G_FALSE,
7121: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,
7122: P_BILL_HEADER_REC => P_BILL_HEADERS_TBL(l_Count),
7123: P_BILL_LINES_TBL => l_bill_lines_tbl,

Line 7120: P_COMMIT => FND_API.G_FALSE,

7116: /* Create a single offcycle bill */
7117: CREATE_SINGLE_OFFCYCLE_BILL(
7118: P_API_VERSION => 1.0,
7119: P_INIT_MSG_LIST => FND_API.G_TRUE,
7120: P_COMMIT => FND_API.G_FALSE,
7121: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,
7122: P_BILL_HEADER_REC => P_BILL_HEADERS_TBL(l_Count),
7123: P_BILL_LINES_TBL => l_bill_lines_tbl,
7124: X_RETURN_STATUS => l_return_status,

Line 7121: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,

7117: CREATE_SINGLE_OFFCYCLE_BILL(
7118: P_API_VERSION => 1.0,
7119: P_INIT_MSG_LIST => FND_API.G_TRUE,
7120: P_COMMIT => FND_API.G_FALSE,
7121: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,
7122: P_BILL_HEADER_REC => P_BILL_HEADERS_TBL(l_Count),
7123: P_BILL_LINES_TBL => l_bill_lines_tbl,
7124: X_RETURN_STATUS => l_return_status,
7125: X_MSG_COUNT => l_msg_count,

Line 7128: IF l_return_status <> FND_API.G_RET_STS_SUCCESS THEN

7124: X_RETURN_STATUS => l_return_status,
7125: X_MSG_COUNT => l_msg_count,
7126: X_MSG_DATA => l_msg_data);
7127:
7128: IF l_return_status <> FND_API.G_RET_STS_SUCCESS THEN
7129: RAISE FND_API.G_EXC_ERROR;
7130: END IF;
7131:
7132: END LOOP;

Line 7129: RAISE FND_API.G_EXC_ERROR;

7125: X_MSG_COUNT => l_msg_count,
7126: X_MSG_DATA => l_msg_data);
7127:
7128: IF l_return_status <> FND_API.G_RET_STS_SUCCESS THEN
7129: RAISE FND_API.G_EXC_ERROR;
7130: END IF;
7131:
7132: END LOOP;
7133:

Line 7137: if P_COMMIT = FND_API.G_TRUE then

7133:
7134: LogMessage(FND_LOG.LEVEL_UNEXPECTED, '______________');
7135: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Total processed ' || P_BILL_HEADERS_TBL.count || ' OFFCYCLE bill(s)');
7136:
7137: if P_COMMIT = FND_API.G_TRUE then
7138: COMMIT WORK;
7139: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Commited loan');
7140: end if;
7141:

Line 7143: x_return_status := FND_API.G_RET_STS_SUCCESS;

7139: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Commited loan');
7140: end if;
7141:
7142: -- END OF BODY OF API
7143: x_return_status := FND_API.G_RET_STS_SUCCESS;
7144:
7145: -- Standard call to get message count and if count is 1, get message info
7146: FND_MSG_PUB.Count_And_Get(
7147: p_encoded => FND_API.G_FALSE,

Line 7147: p_encoded => FND_API.G_FALSE,

7143: x_return_status := FND_API.G_RET_STS_SUCCESS;
7144:
7145: -- Standard call to get message count and if count is 1, get message info
7146: FND_MSG_PUB.Count_And_Get(
7147: p_encoded => FND_API.G_FALSE,
7148: p_count => x_msg_count,
7149: p_data => x_msg_data);
7150:
7151: LogMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME || '.' || l_api_name || ' -');

Line 7154: WHEN FND_API.G_EXC_ERROR THEN

7150:
7151: LogMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME || '.' || l_api_name || ' -');
7152:
7153: EXCEPTION
7154: WHEN FND_API.G_EXC_ERROR THEN
7155: ROLLBACK TO CREATE_OFFCYCLE_BILLS;
7156: x_return_status := FND_API.G_RET_STS_ERROR;
7157: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
7158: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Rollbacked loan');

Line 7156: x_return_status := FND_API.G_RET_STS_ERROR;

7152:
7153: EXCEPTION
7154: WHEN FND_API.G_EXC_ERROR THEN
7155: ROLLBACK TO CREATE_OFFCYCLE_BILLS;
7156: x_return_status := FND_API.G_RET_STS_ERROR;
7157: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
7158: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Rollbacked loan');
7159: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
7160: ROLLBACK TO CREATE_OFFCYCLE_BILLS;

Line 7159: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN

7155: ROLLBACK TO CREATE_OFFCYCLE_BILLS;
7156: x_return_status := FND_API.G_RET_STS_ERROR;
7157: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
7158: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Rollbacked loan');
7159: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
7160: ROLLBACK TO CREATE_OFFCYCLE_BILLS;
7161: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
7162: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
7163: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Rollbacked loan');

Line 7161: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;

7157: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
7158: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Rollbacked loan');
7159: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
7160: ROLLBACK TO CREATE_OFFCYCLE_BILLS;
7161: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
7162: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
7163: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Rollbacked loan');
7164: WHEN OTHERS THEN
7165: ROLLBACK TO CREATE_OFFCYCLE_BILLS;

Line 7166: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;

7162: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
7163: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Rollbacked loan');
7164: WHEN OTHERS THEN
7165: ROLLBACK TO CREATE_OFFCYCLE_BILLS;
7166: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
7167: IF FND_MSG_PUB.Check_Msg_Level(FND_MSG_PUB.G_MSG_LVL_UNEXP_ERROR)THEN
7168: FND_MSG_PUB.Add_Exc_Msg(G_PKG_NAME, l_api_name);
7169: END IF;
7170: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);

Line 7294: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version, l_api_name, G_PKG_NAME) THEN

7290: SAVEPOINT REVERSE_OFFCYCLE_BILL;
7291: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Savepoint is established');
7292:
7293: -- Standard call to check for call compatibility
7294: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version, l_api_name, G_PKG_NAME) THEN
7295: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
7296: END IF;
7297:
7298: -- Initialize message list if p_init_msg_list is set to TRUE

Line 7295: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;

7291: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Savepoint is established');
7292:
7293: -- Standard call to check for call compatibility
7294: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version, l_api_name, G_PKG_NAME) THEN
7295: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
7296: END IF;
7297:
7298: -- Initialize message list if p_init_msg_list is set to TRUE
7299: IF FND_API.To_Boolean(p_init_msg_list) THEN

Line 7299: IF FND_API.To_Boolean(p_init_msg_list) THEN

7295: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
7296: END IF;
7297:
7298: -- Initialize message list if p_init_msg_list is set to TRUE
7299: IF FND_API.To_Boolean(p_init_msg_list) THEN
7300: FND_MSG_PUB.initialize;
7301: END IF;
7302:
7303: -- Initialize API return status to success

Line 7304: l_return_status := FND_API.G_RET_STS_SUCCESS;

7300: FND_MSG_PUB.initialize;
7301: END IF;
7302:
7303: -- Initialize API return status to success
7304: l_return_status := FND_API.G_RET_STS_SUCCESS;
7305:
7306: -- START OF BODY OF API
7307:
7308: init;

Line 7318: RAISE FND_API.G_EXC_ERROR;

7314: -- LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'ERROR: Amortization ID must be set.');
7315: FND_MESSAGE.SET_NAME('LNS', 'LNS_MAN_REV_NO_AMORT');
7316: FND_MSG_PUB.Add;
7317: LogMessage(FND_LOG.LEVEL_UNEXPECTED, FND_MSG_PUB.Get(p_encoded => 'F'));
7318: RAISE FND_API.G_EXC_ERROR;
7319: end if;
7320:
7321: /* verify is it really offcycle bill, reversed etc. */
7322: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Querying for details of the amortization:');

Line 7338: RAISE FND_API.G_EXC_ERROR;

7334: -- LogMessage(FND_LOG.LEVEL_ERROR, 'ERROR: No amortization record found.');
7335: FND_MESSAGE.SET_NAME('LNS', 'LNS_MAN_REV_NO_BILL_FOUND');
7336: FND_MSG_PUB.Add;
7337: LogMessage(FND_LOG.LEVEL_ERROR, FND_MSG_PUB.Get(p_encoded => 'F'));
7338: RAISE FND_API.G_EXC_ERROR;
7339:
7340: else
7341:
7342: LogMessage(FND_LOG.LEVEL_STATEMENT, 'LOAN_ID: ' || l_LOAN_ID);

Line 7354: RAISE FND_API.G_EXC_ERROR;

7350: -- LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'ERROR: The amortization is not offcycle bill.');
7351: FND_MESSAGE.SET_NAME('LNS', 'LNS_MAN_REV_NOT_MAN_BILL');
7352: FND_MSG_PUB.Add;
7353: LogMessage(FND_LOG.LEVEL_ERROR, FND_MSG_PUB.Get(p_encoded => 'F'));
7354: RAISE FND_API.G_EXC_ERROR;
7355:
7356: elsif l_REVERSED_FLAG = 'Y' then
7357:
7358: -- LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'ERROR: The amortization is already reversed.');

Line 7362: RAISE FND_API.G_EXC_ERROR;

7358: -- LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'ERROR: The amortization is already reversed.');
7359: FND_MESSAGE.SET_NAME('LNS', 'LNS_MAN_REV_ALREADY_REV');
7360: FND_MSG_PUB.Add;
7361: LogMessage(FND_LOG.LEVEL_ERROR, FND_MSG_PUB.Get(p_encoded => 'F'));
7362: RAISE FND_API.G_EXC_ERROR;
7363:
7364: end if;
7365:
7366: end if;

Line 7409: RAISE FND_API.G_EXC_ERROR;

7405: -- LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'ERROR: No trx lines found to reverse.');
7406: FND_MESSAGE.SET_NAME('LNS', 'LNS_NO_TRX_LINES_TO_REV');
7407: FND_MSG_PUB.Add;
7408: LogMessage(FND_LOG.LEVEL_ERROR, FND_MSG_PUB.Get(p_encoded => 'F'));
7409: RAISE FND_API.G_EXC_ERROR;
7410:
7411: end if;
7412:
7413: /* Create credit memos */

Line 7437: if P_COMMIT = FND_API.G_TRUE then

7433: END IF;
7434:
7435: STORE_LAST_PAYMENT_NUMBER(l_LOAN_ID);
7436:
7437: if P_COMMIT = FND_API.G_TRUE then
7438: COMMIT WORK;
7439: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Commited');
7440: end if;
7441:

Line 7445: x_return_status := FND_API.G_RET_STS_SUCCESS;

7441:
7442: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Successfully reversed offcycle bill');
7443:
7444: -- END OF BODY OF API
7445: x_return_status := FND_API.G_RET_STS_SUCCESS;
7446:
7447: -- Standard call to get message count and if count is 1, get message info
7448: FND_MSG_PUB.Count_And_Get(
7449: p_encoded => FND_API.G_FALSE,

Line 7449: p_encoded => FND_API.G_FALSE,

7445: x_return_status := FND_API.G_RET_STS_SUCCESS;
7446:
7447: -- Standard call to get message count and if count is 1, get message info
7448: FND_MSG_PUB.Count_And_Get(
7449: p_encoded => FND_API.G_FALSE,
7450: p_count => x_msg_count,
7451: p_data => x_msg_data);
7452:
7453: LogMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME || '.' || l_api_name || ' -');

Line 7456: WHEN FND_API.G_EXC_ERROR THEN

7452:
7453: LogMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME || '.' || l_api_name || ' -');
7454:
7455: EXCEPTION
7456: WHEN FND_API.G_EXC_ERROR THEN
7457: ROLLBACK TO REVERSE_OFFCYCLE_BILL;
7458: x_return_status := FND_API.G_RET_STS_ERROR;
7459: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
7460: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Rollbacked');

Line 7458: x_return_status := FND_API.G_RET_STS_ERROR;

7454:
7455: EXCEPTION
7456: WHEN FND_API.G_EXC_ERROR THEN
7457: ROLLBACK TO REVERSE_OFFCYCLE_BILL;
7458: x_return_status := FND_API.G_RET_STS_ERROR;
7459: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
7460: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Rollbacked');
7461: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
7462: ROLLBACK TO REVERSE_OFFCYCLE_BILL;

Line 7461: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN

7457: ROLLBACK TO REVERSE_OFFCYCLE_BILL;
7458: x_return_status := FND_API.G_RET_STS_ERROR;
7459: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
7460: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Rollbacked');
7461: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
7462: ROLLBACK TO REVERSE_OFFCYCLE_BILL;
7463: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
7464: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
7465: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Rollbacked');

Line 7463: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;

7459: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
7460: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Rollbacked');
7461: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
7462: ROLLBACK TO REVERSE_OFFCYCLE_BILL;
7463: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
7464: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
7465: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Rollbacked');
7466: WHEN OTHERS THEN
7467: ROLLBACK TO REVERSE_OFFCYCLE_BILL;

Line 7468: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;

7464: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
7465: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Rollbacked');
7466: WHEN OTHERS THEN
7467: ROLLBACK TO REVERSE_OFFCYCLE_BILL;
7468: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
7469: IF FND_MSG_PUB.Check_Msg_Level(FND_MSG_PUB.G_MSG_LVL_UNEXP_ERROR)THEN
7470: FND_MSG_PUB.Add_Exc_Msg(G_PKG_NAME, l_api_name);
7471: END IF;
7472: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);

Line 7615: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version, l_api_name, G_PKG_NAME) THEN

7611: SAVEPOINT ADJUST_ORIGINAL_RECEIVABLE;
7612: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Savepoint is established');
7613:
7614: -- Standard call to check for call compatibility
7615: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version, l_api_name, G_PKG_NAME) THEN
7616: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
7617: END IF;
7618:
7619: -- Initialize message list if p_init_msg_list is set to TRUE

Line 7616: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;

7612: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Savepoint is established');
7613:
7614: -- Standard call to check for call compatibility
7615: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version, l_api_name, G_PKG_NAME) THEN
7616: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
7617: END IF;
7618:
7619: -- Initialize message list if p_init_msg_list is set to TRUE
7620: IF FND_API.To_Boolean(p_init_msg_list) THEN

Line 7620: IF FND_API.To_Boolean(p_init_msg_list) THEN

7616: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
7617: END IF;
7618:
7619: -- Initialize message list if p_init_msg_list is set to TRUE
7620: IF FND_API.To_Boolean(p_init_msg_list) THEN
7621: FND_MSG_PUB.initialize;
7622: END IF;
7623:
7624: -- Initialize API return status to success

Line 7625: l_return_status := FND_API.G_RET_STS_SUCCESS;

7621: FND_MSG_PUB.initialize;
7622: END IF;
7623:
7624: -- Initialize API return status to success
7625: l_return_status := FND_API.G_RET_STS_SUCCESS;
7626:
7627: -- START OF BODY OF API
7628:
7629: init;

Line 7640: RAISE FND_API.G_EXC_ERROR;

7636: -- LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'ERROR: Loan must be set.');
7637: FND_MESSAGE.SET_NAME('LNS', 'LNS_NO_LOAN');
7638: FND_MSG_PUB.Add;
7639: LogMessage(FND_LOG.LEVEL_UNEXPECTED, FND_MSG_PUB.Get(p_encoded => 'F'));
7640: RAISE FND_API.G_EXC_ERROR;
7641:
7642: end if;
7643:
7644: /* checking for system options values required for adjustment */

Line 7650: RAISE FND_API.G_EXC_ERROR;

7646: -- LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'ERROR: Receivables activity name is not set in the system option.');
7647: FND_MESSAGE.SET_NAME('LNS', 'LNS_NO_REC_TRX_IN_SYS_OPT');
7648: FND_MSG_PUB.Add;
7649: LogMessage(FND_LOG.LEVEL_UNEXPECTED, FND_MSG_PUB.Get(p_encoded => 'F'));
7650: RAISE FND_API.G_EXC_ERROR;
7651:
7652: end if;
7653:
7654:

Line 7666: RAISE FND_API.G_EXC_ERROR;

7662: -- LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'ERROR: USSGL Transaction Code is not set in the system option.');
7663: FND_MESSAGE.SET_NAME('LNS', 'LNS_NO_TRX_CODE_IN_SYS_OPT');
7664: FND_MSG_PUB.Add;
7665: LogMessage(FND_LOG.LEVEL_UNEXPECTED, FND_MSG_PUB.Get(p_encoded => 'F'));
7666: RAISE FND_API.G_EXC_ERROR;
7667:
7668: end if;
7669:
7670: end if;

Line 7713: RAISE FND_API.G_EXC_ERROR;

7709: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Receivable remaining amount: ' || l_amount_due_remaining);
7710: FND_MESSAGE.SET_NAME('LNS', 'LNS_INVALID_ADJ_AMT');
7711: FND_MSG_PUB.Add;
7712: LogMessage(FND_LOG.LEVEL_UNEXPECTED, FND_MSG_PUB.Get(p_encoded => 'F'));
7713: RAISE FND_API.G_EXC_ERROR;
7714: else
7715: l_type := 'LINE';
7716: end if;
7717:

Line 7728: RAISE FND_API.G_EXC_ERROR;

7724: FND_MESSAGE.SET_NAME('LNS', 'LNS_DUPL_ADJ_ORIG_REC');
7725: FND_MESSAGE.SET_TOKEN('ADJ', l_adj_number);
7726: FND_MSG_PUB.Add;
7727: LogMessage(FND_LOG.LEVEL_UNEXPECTED, FND_MSG_PUB.Get(p_encoded => 'F'));
7728: RAISE FND_API.G_EXC_ERROR;
7729: end if;
7730:
7731: /* buld comments */
7732: l_comments := 'Loan ' || l_loan_number || ' - line ' || l_Count;

Line 7773: p_init_msg_list => FND_API.G_FALSE

7769: P_ORG_ID => l_org_id);
7770:
7771: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Updating LNS_LOAN_LINES...');
7772: LNS_LOAN_LINE_PUB.UPDATE_LINE_ADJUSTMENT_NUMBER(
7773: p_init_msg_list => FND_API.G_FALSE
7774: ,p_loan_id => P_LOAN_ID
7775: ,p_loan_line_id => l_line_id
7776: ,p_rec_adjustment_number => l_adj_number
7777: ,p_rec_adjustment_id => l_adj_id

Line 7790: RAISE FND_API.G_EXC_ERROR;

7786: LogMessage(FND_LOG.LEVEL_STATEMENT, 'l_return_status: ' || l_return_status);
7787: IF l_return_status = 'S' THEN
7788: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Successfully updated LNS_LOAN_LINES');
7789: ELSE
7790: RAISE FND_API.G_EXC_ERROR;
7791: END IF;
7792: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Successfully created adjustment ' || l_adj_number || ' for original receivable ' || l_trx_number);
7793:
7794: END LOOP;

Line 7803: RAISE FND_API.G_EXC_ERROR;

7799: -- LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'ERROR: Cannot find receivable to adjust.');
7800: FND_MESSAGE.SET_NAME('LNS', 'LNS_CANT_FIND_ORIG_REC');
7801: FND_MSG_PUB.Add;
7802: LogMessage(FND_LOG.LEVEL_UNEXPECTED, FND_MSG_PUB.Get(p_encoded => 'F'));
7803: RAISE FND_API.G_EXC_ERROR;
7804: end if;
7805:
7806: if P_COMMIT = FND_API.G_TRUE then
7807: COMMIT WORK;

Line 7806: if P_COMMIT = FND_API.G_TRUE then

7802: LogMessage(FND_LOG.LEVEL_UNEXPECTED, FND_MSG_PUB.Get(p_encoded => 'F'));
7803: RAISE FND_API.G_EXC_ERROR;
7804: end if;
7805:
7806: if P_COMMIT = FND_API.G_TRUE then
7807: COMMIT WORK;
7808: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Commited');
7809: end if;
7810:

Line 7814: x_return_status := FND_API.G_RET_STS_SUCCESS;

7810:
7811: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Successfully adjusted ' || l_Count || ' original receivable for loan ' || l_loan_number);
7812:
7813: -- END OF BODY OF API
7814: x_return_status := FND_API.G_RET_STS_SUCCESS;
7815:
7816: -- Standard call to get message count and if count is 1, get message info
7817: FND_MSG_PUB.Count_And_Get(
7818: p_encoded => FND_API.G_FALSE,

Line 7818: p_encoded => FND_API.G_FALSE,

7814: x_return_status := FND_API.G_RET_STS_SUCCESS;
7815:
7816: -- Standard call to get message count and if count is 1, get message info
7817: FND_MSG_PUB.Count_And_Get(
7818: p_encoded => FND_API.G_FALSE,
7819: p_count => x_msg_count,
7820: p_data => x_msg_data);
7821:
7822: LogMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME || '.' || l_api_name || ' -');

Line 7825: WHEN FND_API.G_EXC_ERROR THEN

7821:
7822: LogMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME || '.' || l_api_name || ' -');
7823:
7824: EXCEPTION
7825: WHEN FND_API.G_EXC_ERROR THEN
7826: ROLLBACK TO ADJUST_ORIGINAL_RECEIVABLE;
7827: x_return_status := FND_API.G_RET_STS_ERROR;
7828: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
7829: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Rollbacked');

Line 7827: x_return_status := FND_API.G_RET_STS_ERROR;

7823:
7824: EXCEPTION
7825: WHEN FND_API.G_EXC_ERROR THEN
7826: ROLLBACK TO ADJUST_ORIGINAL_RECEIVABLE;
7827: x_return_status := FND_API.G_RET_STS_ERROR;
7828: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
7829: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Rollbacked');
7830: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
7831: ROLLBACK TO ADJUST_ORIGINAL_RECEIVABLE;

Line 7830: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN

7826: ROLLBACK TO ADJUST_ORIGINAL_RECEIVABLE;
7827: x_return_status := FND_API.G_RET_STS_ERROR;
7828: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
7829: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Rollbacked');
7830: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
7831: ROLLBACK TO ADJUST_ORIGINAL_RECEIVABLE;
7832: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
7833: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
7834: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Rollbacked');

Line 7832: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;

7828: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
7829: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Rollbacked');
7830: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
7831: ROLLBACK TO ADJUST_ORIGINAL_RECEIVABLE;
7832: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
7833: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
7834: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Rollbacked');
7835: WHEN OTHERS THEN
7836: ROLLBACK TO ADJUST_ORIGINAL_RECEIVABLE;

Line 7837: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;

7833: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
7834: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Rollbacked');
7835: WHEN OTHERS THEN
7836: ROLLBACK TO ADJUST_ORIGINAL_RECEIVABLE;
7837: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
7838: IF FND_MSG_PUB.Check_Msg_Level(FND_MSG_PUB.G_MSG_LVL_UNEXP_ERROR)THEN
7839: FND_MSG_PUB.Add_Exc_Msg(G_PKG_NAME, l_api_name);
7840: END IF;
7841: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);

Line 7938: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version, l_api_name, G_PKG_NAME) THEN

7934: SAVEPOINT PREBILL_SINGLE_LOAN;
7935: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Savepoint is established');
7936:
7937: -- Standard call to check for call compatibility
7938: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version, l_api_name, G_PKG_NAME) THEN
7939: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
7940: END IF;
7941:
7942: -- Initialize message list if p_init_msg_list is set to TRUE

Line 7939: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;

7935: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Savepoint is established');
7936:
7937: -- Standard call to check for call compatibility
7938: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version, l_api_name, G_PKG_NAME) THEN
7939: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
7940: END IF;
7941:
7942: -- Initialize message list if p_init_msg_list is set to TRUE
7943: IF FND_API.To_Boolean(p_init_msg_list) THEN

Line 7943: IF FND_API.To_Boolean(p_init_msg_list) THEN

7939: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
7940: END IF;
7941:
7942: -- Initialize message list if p_init_msg_list is set to TRUE
7943: IF FND_API.To_Boolean(p_init_msg_list) THEN
7944: FND_MSG_PUB.initialize;
7945: END IF;
7946:
7947: -- Initialize API return status to success

Line 7948: l_return_status := FND_API.G_RET_STS_SUCCESS;

7944: FND_MSG_PUB.initialize;
7945: END IF;
7946:
7947: -- Initialize API return status to success
7948: l_return_status := FND_API.G_RET_STS_SUCCESS;
7949:
7950: -- START OF BODY OF API
7951: l_installment_num := 0;
7952:

Line 7960: RAISE FND_API.G_EXC_ERROR;

7956: -- LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'ERROR: Loan must be set.');
7957: FND_MESSAGE.SET_NAME('LNS', 'LNS_NO_LOAN');
7958: FND_MSG_PUB.Add;
7959: LogMessage(FND_LOG.LEVEL_UNEXPECTED, FND_MSG_PUB.Get(p_encoded => 'F'));
7960: RAISE FND_API.G_EXC_ERROR;
7961:
7962: end if;
7963:
7964: /* getting loan_number */

Line 7979: p_init_msg_list => FND_API.G_TRUE,

7975:
7976: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Calling lns_financials.getInstallment...');
7977: lns_financials.getInstallment(
7978: p_api_version => 1.0,
7979: p_init_msg_list => FND_API.G_TRUE,
7980: p_commit => FND_API.G_FALSE,
7981: p_loan_Id => P_LOAN_ID,
7982: p_installment_number => l_installment_num,
7983: x_amortization_rec => l_amortization_rec,

Line 7980: p_commit => FND_API.G_FALSE,

7976: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Calling lns_financials.getInstallment...');
7977: lns_financials.getInstallment(
7978: p_api_version => 1.0,
7979: p_init_msg_list => FND_API.G_TRUE,
7980: p_commit => FND_API.G_FALSE,
7981: p_loan_Id => P_LOAN_ID,
7982: p_installment_number => l_installment_num,
7983: x_amortization_rec => l_amortization_rec,
7984: x_fees_tbl => l_fee_tbl,

Line 7994: p_init_msg_list => FND_API.G_TRUE,

7990:
7991: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Calling lns_financials.getOpenInstallment...');
7992: lns_financials.getOpenInstallment(
7993: -- p_api_version => 1.0,
7994: p_init_msg_list => FND_API.G_TRUE,
7995: -- p_commit => FND_API.G_FALSE,
7996: p_loan_Id => P_LOAN_ID,
7997: p_installment_number => l_installment_num,
7998: x_amortization_rec => l_amortization_rec,

Line 7995: -- p_commit => FND_API.G_FALSE,

7991: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Calling lns_financials.getOpenInstallment...');
7992: lns_financials.getOpenInstallment(
7993: -- p_api_version => 1.0,
7994: p_init_msg_list => FND_API.G_TRUE,
7995: -- p_commit => FND_API.G_FALSE,
7996: p_loan_Id => P_LOAN_ID,
7997: p_installment_number => l_installment_num,
7998: x_amortization_rec => l_amortization_rec,
7999: x_fees_tbl => l_fee_tbl,

Line 8010: RAISE FND_API.G_EXC_ERROR;

8006: LogMessage(FND_LOG.LEVEL_STATEMENT, 'l_return_status: ' || l_return_status);
8007: LogMessage(FND_LOG.LEVEL_STATEMENT, 'l_msg_data: ' || substr(l_msg_data,1,225));
8008:
8009: if l_return_status <> 'S' then
8010: RAISE FND_API.G_EXC_ERROR;
8011: end if;
8012:
8013: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Data returned from lns_financials.getInstallment:');
8014: LogMessage(FND_LOG.LEVEL_STATEMENT, 'INSTALLMENT_NUMBER: ' || l_amortization_rec.INSTALLMENT_NUMBER);

Line 8092: RAISE FND_API.G_EXC_ERROR;

8088:
8089: FND_MESSAGE.SET_NAME('LNS', 'LNS_INVALID_FEE_INSTAL');
8090: FND_MSG_PUB.Add;
8091: LogMessage(FND_LOG.LEVEL_UNEXPECTED, FND_MSG_PUB.Get(p_encoded => 'F'));
8092: RAISE FND_API.G_EXC_ERROR;
8093:
8094: end if;
8095:
8096: /* updating LNS_FEE_SCHEDULES with billed_flag = Y */

Line 8114: P_INIT_MSG_LIST => FND_API.G_TRUE,

8110: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Calling LNS_BILLING_BATCH_PUB.CREATE_OFFCYCLE_BILLS...');
8111:
8112: LNS_BILLING_BATCH_PUB.CREATE_OFFCYCLE_BILLS(
8113: P_API_VERSION => 1.0,
8114: P_INIT_MSG_LIST => FND_API.G_TRUE,
8115: P_COMMIT => FND_API.G_FALSE,
8116: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,
8117: P_BILL_HEADERS_TBL => l_BILL_HEADERS_TBL,
8118: P_BILL_LINES_TBL => l_BILL_LINES_TBL,

Line 8115: P_COMMIT => FND_API.G_FALSE,

8111:
8112: LNS_BILLING_BATCH_PUB.CREATE_OFFCYCLE_BILLS(
8113: P_API_VERSION => 1.0,
8114: P_INIT_MSG_LIST => FND_API.G_TRUE,
8115: P_COMMIT => FND_API.G_FALSE,
8116: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,
8117: P_BILL_HEADERS_TBL => l_BILL_HEADERS_TBL,
8118: P_BILL_LINES_TBL => l_BILL_LINES_TBL,
8119: x_return_status => l_return_status,

Line 8116: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,

8112: LNS_BILLING_BATCH_PUB.CREATE_OFFCYCLE_BILLS(
8113: P_API_VERSION => 1.0,
8114: P_INIT_MSG_LIST => FND_API.G_TRUE,
8115: P_COMMIT => FND_API.G_FALSE,
8116: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,
8117: P_BILL_HEADERS_TBL => l_BILL_HEADERS_TBL,
8118: P_BILL_LINES_TBL => l_BILL_LINES_TBL,
8119: x_return_status => l_return_status,
8120: x_msg_count => l_msg_count,

Line 8126: RAISE FND_API.G_EXC_ERROR;

8122:
8123: LogMessage(FND_LOG.LEVEL_STATEMENT, 'l_return_status: ' || l_return_status);
8124:
8125: if l_return_status <> 'S' then
8126: RAISE FND_API.G_EXC_ERROR;
8127: end if;
8128:
8129: if P_COMMIT = FND_API.G_TRUE then
8130: COMMIT WORK;

Line 8129: if P_COMMIT = FND_API.G_TRUE then

8125: if l_return_status <> 'S' then
8126: RAISE FND_API.G_EXC_ERROR;
8127: end if;
8128:
8129: if P_COMMIT = FND_API.G_TRUE then
8130: COMMIT WORK;
8131: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Commited');
8132: end if;
8133:

Line 8137: x_return_status := FND_API.G_RET_STS_SUCCESS;

8133:
8134: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Successfully billed 0-th installment for loan ' || l_loan_number);
8135:
8136: -- END OF BODY OF API
8137: x_return_status := FND_API.G_RET_STS_SUCCESS;
8138: X_BILLED_YN := 'Y';
8139:
8140: -- Standard call to get message count and if count is 1, get message info
8141: FND_MSG_PUB.Count_And_Get(

Line 8142: p_encoded => FND_API.G_FALSE,

8138: X_BILLED_YN := 'Y';
8139:
8140: -- Standard call to get message count and if count is 1, get message info
8141: FND_MSG_PUB.Count_And_Get(
8142: p_encoded => FND_API.G_FALSE,
8143: p_count => x_msg_count,
8144: p_data => x_msg_data);
8145:
8146: LogMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME || '.' || l_api_name || ' -');

Line 8149: WHEN FND_API.G_EXC_ERROR THEN

8145:
8146: LogMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME || '.' || l_api_name || ' -');
8147:
8148: EXCEPTION
8149: WHEN FND_API.G_EXC_ERROR THEN
8150: ROLLBACK TO PREBILL_SINGLE_LOAN;
8151: x_return_status := FND_API.G_RET_STS_ERROR;
8152: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
8153: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Rollbacked');

Line 8151: x_return_status := FND_API.G_RET_STS_ERROR;

8147:
8148: EXCEPTION
8149: WHEN FND_API.G_EXC_ERROR THEN
8150: ROLLBACK TO PREBILL_SINGLE_LOAN;
8151: x_return_status := FND_API.G_RET_STS_ERROR;
8152: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
8153: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Rollbacked');
8154: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
8155: ROLLBACK TO PREBILL_SINGLE_LOAN;

Line 8154: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN

8150: ROLLBACK TO PREBILL_SINGLE_LOAN;
8151: x_return_status := FND_API.G_RET_STS_ERROR;
8152: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
8153: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Rollbacked');
8154: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
8155: ROLLBACK TO PREBILL_SINGLE_LOAN;
8156: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
8157: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
8158: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Rollbacked');

Line 8156: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;

8152: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
8153: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Rollbacked');
8154: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
8155: ROLLBACK TO PREBILL_SINGLE_LOAN;
8156: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
8157: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
8158: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Rollbacked');
8159: WHEN OTHERS THEN
8160: ROLLBACK TO PREBILL_SINGLE_LOAN;

Line 8161: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;

8157: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
8158: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Rollbacked');
8159: WHEN OTHERS THEN
8160: ROLLBACK TO PREBILL_SINGLE_LOAN;
8161: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
8162: IF FND_MSG_PUB.Check_Msg_Level(FND_MSG_PUB.G_MSG_LVL_UNEXP_ERROR)THEN
8163: FND_MSG_PUB.Add_Exc_Msg(G_PKG_NAME, l_api_name);
8164: END IF;
8165: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);

Line 8249: RAISE FND_API.G_EXC_ERROR;

8245: -- LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'ERROR: Loan must be set.');
8246: FND_MESSAGE.SET_NAME('LNS', 'LNS_NO_LOAN');
8247: FND_MSG_PUB.Add;
8248: LogMessage(FND_LOG.LEVEL_UNEXPECTED, FND_MSG_PUB.Get(p_encoded => 'F'));
8249: RAISE FND_API.G_EXC_ERROR;
8250:
8251: end if;
8252: if P_AMOUNT is null then
8253:

Line 8255: RAISE FND_API.G_EXC_ERROR;

8251: end if;
8252: if P_AMOUNT is null then
8253:
8254: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'P_AMOUNT is null');
8255: RAISE FND_API.G_EXC_ERROR;
8256:
8257: end if;
8258:
8259: init;

Line 8426: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version, l_api_name, G_PKG_NAME) THEN

8422: SAVEPOINT FORGIVENESS_ADJUSTMENT;
8423: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Savepoint is established');
8424:
8425: -- Standard call to check for call compatibility
8426: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version, l_api_name, G_PKG_NAME) THEN
8427: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
8428: END IF;
8429:
8430: -- Initialize message list if p_init_msg_list is set to TRUE

Line 8427: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;

8423: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Savepoint is established');
8424:
8425: -- Standard call to check for call compatibility
8426: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version, l_api_name, G_PKG_NAME) THEN
8427: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
8428: END IF;
8429:
8430: -- Initialize message list if p_init_msg_list is set to TRUE
8431: IF FND_API.To_Boolean(p_init_msg_list) THEN

Line 8431: IF FND_API.To_Boolean(p_init_msg_list) THEN

8427: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
8428: END IF;
8429:
8430: -- Initialize message list if p_init_msg_list is set to TRUE
8431: IF FND_API.To_Boolean(p_init_msg_list) THEN
8432: FND_MSG_PUB.initialize;
8433: END IF;
8434:
8435: -- Initialize API return status to success

Line 8436: X_RETURN_STATUS := FND_API.G_RET_STS_SUCCESS;

8432: FND_MSG_PUB.initialize;
8433: END IF;
8434:
8435: -- Initialize API return status to success
8436: X_RETURN_STATUS := FND_API.G_RET_STS_SUCCESS;
8437:
8438: -- START OF BODY OF API
8439: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Input loan_id = ' || P_LOAN_ID);
8440:

Line 8448: RAISE FND_API.G_EXC_ERROR;

8444: -- LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'ERROR: Loan must be set.');
8445: FND_MESSAGE.SET_NAME('LNS', 'LNS_NO_LOAN');
8446: FND_MSG_PUB.Add;
8447: LogMessage(FND_LOG.LEVEL_UNEXPECTED, FND_MSG_PUB.Get(p_encoded => 'F'));
8448: RAISE FND_API.G_EXC_ERROR;
8449:
8450: end if;
8451:
8452: /* checking for system options values required for adjustment */

Line 8497: RAISE FND_API.G_EXC_ERROR;

8493: end if;
8494:
8495: if l_payment_schedule_id is null then
8496: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'ERROR: Cannot create adjustment - principal invoice is INCOMPLETE!');
8497: RAISE FND_API.G_EXC_ERROR;
8498: end if;
8499:
8500: if l_forgiveness_flag = 'N' then
8501: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Loan is not part of loan forgiveness program. Exiting.');

Line 8559: RAISE FND_API.G_EXC_ERROR;

8555:
8556: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'l_adj_number = ' || l_adj_number || ' (l_adj_id = ' || l_adj_id || ')');
8557:
8558: if l_adj_id is null and l_adj_number is null then
8559: RAISE FND_API.G_EXC_ERROR;
8560: end if;
8561:
8562: if P_COMMIT = FND_API.G_TRUE then
8563: COMMIT WORK;

Line 8562: if P_COMMIT = FND_API.G_TRUE then

8558: if l_adj_id is null and l_adj_number is null then
8559: RAISE FND_API.G_EXC_ERROR;
8560: end if;
8561:
8562: if P_COMMIT = FND_API.G_TRUE then
8563: COMMIT WORK;
8564: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Commited');
8565: end if;
8566:

Line 8570: x_return_status := FND_API.G_RET_STS_SUCCESS;

8566:
8567: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Successfully adjusted payment ' || l_payment_number || ' for loan ' || l_loan_number);
8568:
8569: -- END OF BODY OF API
8570: x_return_status := FND_API.G_RET_STS_SUCCESS;
8571:
8572: -- Standard call to get message count and if count is 1, get message info
8573: FND_MSG_PUB.Count_And_Get(
8574: p_encoded => FND_API.G_FALSE,

Line 8574: p_encoded => FND_API.G_FALSE,

8570: x_return_status := FND_API.G_RET_STS_SUCCESS;
8571:
8572: -- Standard call to get message count and if count is 1, get message info
8573: FND_MSG_PUB.Count_And_Get(
8574: p_encoded => FND_API.G_FALSE,
8575: p_count => x_msg_count,
8576: p_data => x_msg_data);
8577:
8578: LogMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME || '.' || l_api_name || ' -');

Line 8581: WHEN FND_API.G_EXC_ERROR THEN

8577:
8578: LogMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME || '.' || l_api_name || ' -');
8579:
8580: EXCEPTION
8581: WHEN FND_API.G_EXC_ERROR THEN
8582: ROLLBACK TO FORGIVENESS_ADJUSTMENT;
8583: x_return_status := FND_API.G_RET_STS_ERROR;
8584: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
8585: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Rollbacked');

Line 8583: x_return_status := FND_API.G_RET_STS_ERROR;

8579:
8580: EXCEPTION
8581: WHEN FND_API.G_EXC_ERROR THEN
8582: ROLLBACK TO FORGIVENESS_ADJUSTMENT;
8583: x_return_status := FND_API.G_RET_STS_ERROR;
8584: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
8585: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Rollbacked');
8586: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
8587: ROLLBACK TO FORGIVENESS_ADJUSTMENT;

Line 8586: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN

8582: ROLLBACK TO FORGIVENESS_ADJUSTMENT;
8583: x_return_status := FND_API.G_RET_STS_ERROR;
8584: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
8585: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Rollbacked');
8586: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
8587: ROLLBACK TO FORGIVENESS_ADJUSTMENT;
8588: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
8589: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
8590: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Rollbacked');

Line 8588: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;

8584: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
8585: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Rollbacked');
8586: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
8587: ROLLBACK TO FORGIVENESS_ADJUSTMENT;
8588: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
8589: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
8590: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Rollbacked');
8591: WHEN OTHERS THEN
8592: ROLLBACK TO FORGIVENESS_ADJUSTMENT;

Line 8593: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;

8589: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
8590: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Rollbacked');
8591: WHEN OTHERS THEN
8592: ROLLBACK TO FORGIVENESS_ADJUSTMENT;
8593: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
8594: IF FND_MSG_PUB.Check_Msg_Level(FND_MSG_PUB.G_MSG_LVL_UNEXP_ERROR)THEN
8595: FND_MSG_PUB.Add_Exc_Msg(G_PKG_NAME, l_api_name);
8596: END IF;
8597: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);

Line 8707: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version, l_api_name, G_PKG_NAME) THEN

8703: SAVEPOINT GET_NEXT_INSTAL_TO_BILL;
8704: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Savepoint is established');
8705:
8706: -- Standard call to check for call compatibility
8707: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version, l_api_name, G_PKG_NAME) THEN
8708: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
8709: END IF;
8710:
8711: -- Initialize message list if p_init_msg_list is set to TRUE

Line 8708: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;

8704: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Savepoint is established');
8705:
8706: -- Standard call to check for call compatibility
8707: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version, l_api_name, G_PKG_NAME) THEN
8708: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
8709: END IF;
8710:
8711: -- Initialize message list if p_init_msg_list is set to TRUE
8712: IF FND_API.To_Boolean(p_init_msg_list) THEN

Line 8712: IF FND_API.To_Boolean(p_init_msg_list) THEN

8708: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
8709: END IF;
8710:
8711: -- Initialize message list if p_init_msg_list is set to TRUE
8712: IF FND_API.To_Boolean(p_init_msg_list) THEN
8713: FND_MSG_PUB.initialize;
8714: END IF;
8715:
8716: -- Initialize API return status to success

Line 8717: X_RETURN_STATUS := FND_API.G_RET_STS_SUCCESS;

8713: FND_MSG_PUB.initialize;
8714: END IF;
8715:
8716: -- Initialize API return status to success
8717: X_RETURN_STATUS := FND_API.G_RET_STS_SUCCESS;
8718:
8719: -- START OF BODY OF API
8720: init;
8721:

Line 8731: RAISE FND_API.G_EXC_ERROR;

8727: -- LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'ERROR: Loan must be set.');
8728: FND_MESSAGE.SET_NAME('LNS', 'LNS_NO_LOAN');
8729: FND_MSG_PUB.Add;
8730: LogMessage(FND_LOG.LEVEL_UNEXPECTED, FND_MSG_PUB.Get(p_encoded => 'F'));
8731: RAISE FND_API.G_EXC_ERROR;
8732:
8733: end if;
8734:
8735: if CAN_BILL_NEXT_INSTAL(P_LOAN_ID) = false then

Line 8740: RAISE FND_API.G_EXC_ERROR;

8736: -- LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Loan is not ready to bill next installment. Returning.');
8737: FND_MESSAGE.SET_NAME('LNS', 'LNS_NOT_READY_BILL_NEXT_INSTAL');
8738: FND_MSG_PUB.Add;
8739: LogMessage(FND_LOG.LEVEL_UNEXPECTED, FND_MSG_PUB.Get(p_encoded => 'F'));
8740: RAISE FND_API.G_EXC_ERROR;
8741: end if;
8742:
8743: -- Bug#6830765 - Added new procedure ..EXT_1, which returns '0' if 0th installment is scheduled and it solves
8744: -- the case if there is no '0th installment' and wants '1st 'installment

Line 8756: p_init_msg_list => FND_API.G_TRUE,

8752:
8753: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Calling lns_financials.getInstallment...');
8754: lns_financials.getInstallment(
8755: p_api_version => 1.0,
8756: p_init_msg_list => FND_API.G_TRUE,
8757: p_commit => FND_API.G_FALSE,
8758: p_loan_Id => P_LOAN_ID,
8759: p_installment_number => l_NEXT_PAYMENT_NUMBER,
8760: x_amortization_rec => l_amortization_rec,

Line 8757: p_commit => FND_API.G_FALSE,

8753: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Calling lns_financials.getInstallment...');
8754: lns_financials.getInstallment(
8755: p_api_version => 1.0,
8756: p_init_msg_list => FND_API.G_TRUE,
8757: p_commit => FND_API.G_FALSE,
8758: p_loan_Id => P_LOAN_ID,
8759: p_installment_number => l_NEXT_PAYMENT_NUMBER,
8760: x_amortization_rec => l_amortization_rec,
8761: x_fees_tbl => l_fee_tbl,

Line 8770: p_init_msg_list => FND_API.G_TRUE,

8766: else
8767:
8768: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Calling lns_financials.getOpenInstallment...');
8769: lns_financials.getOpenInstallment(
8770: p_init_msg_list => FND_API.G_TRUE,
8771: p_loan_Id => P_LOAN_ID,
8772: p_installment_number => l_NEXT_PAYMENT_NUMBER,
8773: x_amortization_rec => l_amortization_rec,
8774: x_fees_tbl => l_fee_tbl,

Line 8785: RAISE FND_API.G_EXC_ERROR;

8781: LogMessage(FND_LOG.LEVEL_STATEMENT, 'l_return_status: ' || l_return_status);
8782: LogMessage(FND_LOG.LEVEL_STATEMENT, 'l_msg_data: ' || l_msg_data);
8783:
8784: if l_return_status <> 'S' then
8785: RAISE FND_API.G_EXC_ERROR;
8786: end if;
8787:
8788: -- remove any msg from the stack
8789: FND_MSG_PUB.initialize;

Line 8807: RAISE FND_API.G_EXC_ERROR;

8803: -- LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'lns_financials.getInstallment returns no data. Nothing to bill. Returning.');
8804: FND_MESSAGE.SET_NAME('LNS', 'LNS_NO_BILLING_DATA');
8805: FND_MSG_PUB.Add;
8806: LogMessage(FND_LOG.LEVEL_UNEXPECTED, FND_MSG_PUB.Get(p_encoded => 'F'));
8807: RAISE FND_API.G_EXC_ERROR;
8808:
8809: end if;
8810:
8811: if l_amortization_rec.PRINCIPAL_AMOUNT = 0 and

Line 8833: RAISE FND_API.G_EXC_ERROR;

8829: FND_MESSAGE.SET_NAME('LNS', 'LNS_CANT_BILL_ZERO_AMOUNT');
8830: FND_MESSAGE.SET_TOKEN('PROFILE', l_profile_name);
8831: FND_MSG_PUB.Add;
8832: LogMessage(FND_LOG.LEVEL_UNEXPECTED, FND_MSG_PUB.Get(p_encoded => 'F'));
8833: RAISE FND_API.G_EXC_ERROR;
8834: -- return;
8835: end if;
8836:
8837: end if;

Line 8951: if P_COMMIT = FND_API.G_TRUE then

8947: end if;
8948:
8949: x_invoices_tbl := l_invoices_tbl;
8950:
8951: if P_COMMIT = FND_API.G_TRUE then
8952: COMMIT WORK;
8953: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Commited');
8954: end if;
8955:

Line 8957: x_return_status := FND_API.G_RET_STS_SUCCESS;

8953: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Commited');
8954: end if;
8955:
8956: -- END OF BODY OF API
8957: x_return_status := FND_API.G_RET_STS_SUCCESS;
8958:
8959: -- Standard call to get message count and if count is 1, get message info
8960: FND_MSG_PUB.Count_And_Get(
8961: p_encoded => FND_API.G_FALSE,

Line 8961: p_encoded => FND_API.G_FALSE,

8957: x_return_status := FND_API.G_RET_STS_SUCCESS;
8958:
8959: -- Standard call to get message count and if count is 1, get message info
8960: FND_MSG_PUB.Count_And_Get(
8961: p_encoded => FND_API.G_FALSE,
8962: p_count => x_msg_count,
8963: p_data => x_msg_data);
8964:
8965: LogMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME || '.' || l_api_name || ' -');

Line 8968: WHEN FND_API.G_EXC_ERROR THEN

8964:
8965: LogMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME || '.' || l_api_name || ' -');
8966:
8967: EXCEPTION
8968: WHEN FND_API.G_EXC_ERROR THEN
8969: ROLLBACK TO GET_NEXT_INSTAL_TO_BILL;
8970: x_return_status := FND_API.G_RET_STS_ERROR;
8971: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
8972: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Rollbacked');

Line 8970: x_return_status := FND_API.G_RET_STS_ERROR;

8966:
8967: EXCEPTION
8968: WHEN FND_API.G_EXC_ERROR THEN
8969: ROLLBACK TO GET_NEXT_INSTAL_TO_BILL;
8970: x_return_status := FND_API.G_RET_STS_ERROR;
8971: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
8972: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Rollbacked');
8973: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
8974: ROLLBACK TO GET_NEXT_INSTAL_TO_BILL;

Line 8973: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN

8969: ROLLBACK TO GET_NEXT_INSTAL_TO_BILL;
8970: x_return_status := FND_API.G_RET_STS_ERROR;
8971: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
8972: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Rollbacked');
8973: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
8974: ROLLBACK TO GET_NEXT_INSTAL_TO_BILL;
8975: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
8976: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
8977: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Rollbacked');

Line 8975: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;

8971: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
8972: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Rollbacked');
8973: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
8974: ROLLBACK TO GET_NEXT_INSTAL_TO_BILL;
8975: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
8976: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
8977: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Rollbacked');
8978: WHEN OTHERS THEN
8979: ROLLBACK TO GET_NEXT_INSTAL_TO_BILL;

Line 8980: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;

8976: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
8977: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Rollbacked');
8978: WHEN OTHERS THEN
8979: ROLLBACK TO GET_NEXT_INSTAL_TO_BILL;
8980: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
8981: IF FND_MSG_PUB.Check_Msg_Level(FND_MSG_PUB.G_MSG_LVL_UNEXP_ERROR)THEN
8982: FND_MSG_PUB.Add_Exc_Msg(G_PKG_NAME, l_api_name);
8983: END IF;
8984: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);

Line 9099: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version, l_api_name, G_PKG_NAME) THEN

9095: SAVEPOINT BILL_AND_PAY_NEXT_INSTAL;
9096: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Savepoint is established');
9097:
9098: -- Standard call to check for call compatibility
9099: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version, l_api_name, G_PKG_NAME) THEN
9100: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
9101: END IF;
9102:
9103: -- Initialize message list if p_init_msg_list is set to TRUE

Line 9100: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;

9096: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Savepoint is established');
9097:
9098: -- Standard call to check for call compatibility
9099: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version, l_api_name, G_PKG_NAME) THEN
9100: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
9101: END IF;
9102:
9103: -- Initialize message list if p_init_msg_list is set to TRUE
9104: IF FND_API.To_Boolean(p_init_msg_list) THEN

Line 9104: IF FND_API.To_Boolean(p_init_msg_list) THEN

9100: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
9101: END IF;
9102:
9103: -- Initialize message list if p_init_msg_list is set to TRUE
9104: IF FND_API.To_Boolean(p_init_msg_list) THEN
9105: FND_MSG_PUB.initialize;
9106: END IF;
9107:
9108: -- Initialize API return status to success

Line 9109: X_RETURN_STATUS := FND_API.G_RET_STS_SUCCESS;

9105: FND_MSG_PUB.initialize;
9106: END IF;
9107:
9108: -- Initialize API return status to success
9109: X_RETURN_STATUS := FND_API.G_RET_STS_SUCCESS;
9110:
9111: -- START OF BODY OF API
9112: init;
9113:

Line 9121: RAISE FND_API.G_EXC_ERROR;

9117: -- LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Loan is not ready to bill next installment. Returning.');
9118: FND_MESSAGE.SET_NAME('LNS', 'LNS_NOT_READY_BILL_NEXT_INSTAL');
9119: FND_MSG_PUB.Add;
9120: LogMessage(FND_LOG.LEVEL_UNEXPECTED, FND_MSG_PUB.Get(p_encoded => 'F'));
9121: RAISE FND_API.G_EXC_ERROR;
9122: end if;
9123:
9124: l_Count1 := 1;
9125: open loan_to_bill_cur(P_LOAN_ID);

Line 9179: P_INIT_MSG_LIST => FND_API.G_TRUE,

9175:
9176: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Calling BILL_LOANS_EXT...');
9177: BILL_LOANS_EXT(
9178: P_API_VERSION => 1.0,
9179: P_INIT_MSG_LIST => FND_API.G_TRUE,
9180: P_COMMIT => FND_API.G_FALSE,
9181: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,
9182: P_LOANS_TO_BILL_TBL => l_loans_to_bill_tbl,
9183: X_RETURN_STATUS => l_return_status,

Line 9180: P_COMMIT => FND_API.G_FALSE,

9176: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Calling BILL_LOANS_EXT...');
9177: BILL_LOANS_EXT(
9178: P_API_VERSION => 1.0,
9179: P_INIT_MSG_LIST => FND_API.G_TRUE,
9180: P_COMMIT => FND_API.G_FALSE,
9181: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,
9182: P_LOANS_TO_BILL_TBL => l_loans_to_bill_tbl,
9183: X_RETURN_STATUS => l_return_status,
9184: X_MSG_COUNT => l_msg_count,

Line 9181: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,

9177: BILL_LOANS_EXT(
9178: P_API_VERSION => 1.0,
9179: P_INIT_MSG_LIST => FND_API.G_TRUE,
9180: P_COMMIT => FND_API.G_FALSE,
9181: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,
9182: P_LOANS_TO_BILL_TBL => l_loans_to_bill_tbl,
9183: X_RETURN_STATUS => l_return_status,
9184: X_MSG_COUNT => l_msg_count,
9185: X_MSG_DATA => l_msg_data);

Line 9190: RAISE FND_API.G_EXC_ERROR;

9186:
9187: IF l_return_status = 'S' THEN
9188: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Successfully billed next due installment.');
9189: ELSE
9190: RAISE FND_API.G_EXC_ERROR;
9191: END IF;
9192:
9193: if P_CASH_RECEIPTS_TBL.count > 0 then
9194:

Line 9202: P_INIT_MSG_LIST => FND_API.G_TRUE,

9198:
9199: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Calling PAY_INSTALLMENTS...');
9200: PAY_INSTALLMENTS(
9201: P_API_VERSION => 1.0,
9202: P_INIT_MSG_LIST => FND_API.G_TRUE,
9203: P_COMMIT => FND_API.G_FALSE,
9204: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,
9205: P_LOAN_ID => P_LOAN_ID,
9206: P_AM_SCHED_TBL => l_am_sched_tbl,

Line 9203: P_COMMIT => FND_API.G_FALSE,

9199: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Calling PAY_INSTALLMENTS...');
9200: PAY_INSTALLMENTS(
9201: P_API_VERSION => 1.0,
9202: P_INIT_MSG_LIST => FND_API.G_TRUE,
9203: P_COMMIT => FND_API.G_FALSE,
9204: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,
9205: P_LOAN_ID => P_LOAN_ID,
9206: P_AM_SCHED_TBL => l_am_sched_tbl,
9207: P_CASH_RECEIPTS_TBL => P_CASH_RECEIPTS_TBL,

Line 9204: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,

9200: PAY_INSTALLMENTS(
9201: P_API_VERSION => 1.0,
9202: P_INIT_MSG_LIST => FND_API.G_TRUE,
9203: P_COMMIT => FND_API.G_FALSE,
9204: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,
9205: P_LOAN_ID => P_LOAN_ID,
9206: P_AM_SCHED_TBL => l_am_sched_tbl,
9207: P_CASH_RECEIPTS_TBL => P_CASH_RECEIPTS_TBL,
9208: X_RETURN_STATUS => l_return_status,

Line 9215: RAISE FND_API.G_EXC_ERROR;

9211:
9212: IF l_return_status = 'S' THEN
9213: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Successfully applied cash receipts.');
9214: ELSE
9215: RAISE FND_API.G_EXC_ERROR;
9216: END IF;
9217:
9218: end if;
9219:

Line 9220: if P_COMMIT = FND_API.G_TRUE then

9216: END IF;
9217:
9218: end if;
9219:
9220: if P_COMMIT = FND_API.G_TRUE then
9221: COMMIT WORK;
9222: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Commited');
9223: end if;
9224:

Line 9226: x_return_status := FND_API.G_RET_STS_SUCCESS;

9222: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Commited');
9223: end if;
9224:
9225: -- END OF BODY OF API
9226: x_return_status := FND_API.G_RET_STS_SUCCESS;
9227:
9228: -- Standard call to get message count and if count is 1, get message info
9229: FND_MSG_PUB.Count_And_Get(
9230: p_encoded => FND_API.G_FALSE,

Line 9230: p_encoded => FND_API.G_FALSE,

9226: x_return_status := FND_API.G_RET_STS_SUCCESS;
9227:
9228: -- Standard call to get message count and if count is 1, get message info
9229: FND_MSG_PUB.Count_And_Get(
9230: p_encoded => FND_API.G_FALSE,
9231: p_count => x_msg_count,
9232: p_data => x_msg_data);
9233:
9234: LogMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME || '.' || l_api_name || ' -');

Line 9237: WHEN FND_API.G_EXC_ERROR THEN

9233:
9234: LogMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME || '.' || l_api_name || ' -');
9235:
9236: EXCEPTION
9237: WHEN FND_API.G_EXC_ERROR THEN
9238: ROLLBACK TO BILL_AND_PAY_NEXT_INSTAL;
9239: x_return_status := FND_API.G_RET_STS_ERROR;
9240: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
9241: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Rollbacked');

Line 9239: x_return_status := FND_API.G_RET_STS_ERROR;

9235:
9236: EXCEPTION
9237: WHEN FND_API.G_EXC_ERROR THEN
9238: ROLLBACK TO BILL_AND_PAY_NEXT_INSTAL;
9239: x_return_status := FND_API.G_RET_STS_ERROR;
9240: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
9241: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Rollbacked');
9242: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
9243: ROLLBACK TO BILL_AND_PAY_NEXT_INSTAL;

Line 9242: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN

9238: ROLLBACK TO BILL_AND_PAY_NEXT_INSTAL;
9239: x_return_status := FND_API.G_RET_STS_ERROR;
9240: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
9241: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Rollbacked');
9242: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
9243: ROLLBACK TO BILL_AND_PAY_NEXT_INSTAL;
9244: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
9245: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
9246: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Rollbacked');

Line 9244: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;

9240: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
9241: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Rollbacked');
9242: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
9243: ROLLBACK TO BILL_AND_PAY_NEXT_INSTAL;
9244: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
9245: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
9246: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Rollbacked');
9247: WHEN OTHERS THEN
9248: ROLLBACK TO BILL_AND_PAY_NEXT_INSTAL;

Line 9249: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;

9245: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
9246: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Rollbacked');
9247: WHEN OTHERS THEN
9248: ROLLBACK TO BILL_AND_PAY_NEXT_INSTAL;
9249: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
9250: IF FND_MSG_PUB.Check_Msg_Level(FND_MSG_PUB.G_MSG_LVL_UNEXP_ERROR)THEN
9251: FND_MSG_PUB.Add_Exc_Msg(G_PKG_NAME, l_api_name);
9252: END IF;
9253: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);

Line 9399: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version, l_api_name, G_PKG_NAME) THEN

9395: SAVEPOINT PAY_INSTALLMENTS;
9396: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Savepoint is established');
9397:
9398: -- Standard call to check for call compatibility
9399: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version, l_api_name, G_PKG_NAME) THEN
9400: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
9401: END IF;
9402:
9403: -- Initialize message list if p_init_msg_list is set to TRUE

Line 9400: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;

9396: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Savepoint is established');
9397:
9398: -- Standard call to check for call compatibility
9399: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version, l_api_name, G_PKG_NAME) THEN
9400: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
9401: END IF;
9402:
9403: -- Initialize message list if p_init_msg_list is set to TRUE
9404: IF FND_API.To_Boolean(p_init_msg_list) THEN

Line 9404: IF FND_API.To_Boolean(p_init_msg_list) THEN

9400: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
9401: END IF;
9402:
9403: -- Initialize message list if p_init_msg_list is set to TRUE
9404: IF FND_API.To_Boolean(p_init_msg_list) THEN
9405: FND_MSG_PUB.initialize;
9406: END IF;
9407:
9408: -- Initialize API return status to success

Line 9409: X_RETURN_STATUS := FND_API.G_RET_STS_SUCCESS;

9405: FND_MSG_PUB.initialize;
9406: END IF;
9407:
9408: -- Initialize API return status to success
9409: X_RETURN_STATUS := FND_API.G_RET_STS_SUCCESS;
9410:
9411: -- START OF BODY OF API
9412: init;
9413:

Line 9645: ,P_INIT_MSG_LIST => FND_API.G_TRUE

9641:
9642: l_error := null;
9643: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Calling AR_RECEIPT_API_PUB.APPLY...');
9644: AR_RECEIPT_API_PUB.APPLY(P_API_VERSION => 1.0
9645: ,P_INIT_MSG_LIST => FND_API.G_TRUE
9646: ,P_COMMIT => FND_API.G_FALSE
9647: ,X_RETURN_STATUS => l_return_status
9648: ,X_MSG_COUNT => l_msg_count
9649: ,X_MSG_DATA => l_msg_data

Line 9646: ,P_COMMIT => FND_API.G_FALSE

9642: l_error := null;
9643: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Calling AR_RECEIPT_API_PUB.APPLY...');
9644: AR_RECEIPT_API_PUB.APPLY(P_API_VERSION => 1.0
9645: ,P_INIT_MSG_LIST => FND_API.G_TRUE
9646: ,P_COMMIT => FND_API.G_FALSE
9647: ,X_RETURN_STATUS => l_return_status
9648: ,X_MSG_COUNT => l_msg_count
9649: ,X_MSG_DATA => l_msg_data
9650: ,p_cash_receipt_id => l_CASH_RECEIPTS_TBL(l_Count1).CASH_RECEIPT_ID

Line 9661: IF l_return_status <> FND_API.G_RET_STS_SUCCESS THEN

9657:
9658: LogMessage(FND_LOG.LEVEL_STATEMENT, 'l_return_status: ' || l_return_status);
9659: LogMessage(FND_LOG.LEVEL_STATEMENT, 'l_msg_data: ' || l_msg_data);
9660:
9661: IF l_return_status <> FND_API.G_RET_STS_SUCCESS THEN
9662: l_error := FND_MSG_PUB.Get(p_encoded => 'F');
9663: END IF;
9664:
9665: EXCEPTION

Line 9667: l_return_status := FND_API.G_RET_STS_ERROR;

9663: END IF;
9664:
9665: EXCEPTION
9666: WHEN OTHERS THEN
9667: l_return_status := FND_API.G_RET_STS_ERROR;
9668: l_error := SQLERRM;
9669: END;
9670:
9671: if l_CASH_RECEIPTS_TBL(l_Count1).RECEIPT_CURRENCY = L_INVOICES_TBL(l_Count).INVOICE_CURRENCY then

Line 9677: IF l_return_status <> FND_API.G_RET_STS_SUCCESS THEN

9673: end if;
9674:
9675: l_application := l_application + 1;
9676:
9677: IF l_return_status <> FND_API.G_RET_STS_SUCCESS THEN
9678: FND_MESSAGE.SET_NAME('LNS', 'LNS_APPL_CR_FAIL');
9679: FND_MSG_PUB.Add;
9680: LogMessage(FND_LOG.LEVEL_UNEXPECTED, FND_MSG_PUB.Get(p_encoded => 'F'));
9681: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Reported error: ' || l_error);

Line 9682: RAISE FND_API.G_EXC_ERROR;

9678: FND_MESSAGE.SET_NAME('LNS', 'LNS_APPL_CR_FAIL');
9679: FND_MSG_PUB.Add;
9680: LogMessage(FND_LOG.LEVEL_UNEXPECTED, FND_MSG_PUB.Get(p_encoded => 'F'));
9681: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Reported error: ' || l_error);
9682: RAISE FND_API.G_EXC_ERROR;
9683: END IF;
9684:
9685: L_INVOICES_TBL(l_Count).REMAINING_AMOUNT := L_INVOICES_TBL(l_Count).REMAINING_AMOUNT - l_apply_amount;
9686: l_CASH_RECEIPTS_TBL(l_Count1).RECEIPT_AMOUNT := l_CASH_RECEIPTS_TBL(l_Count1).RECEIPT_AMOUNT - l_receipt_amount_from;

Line 9709: RAISE FND_API.G_EXC_ERROR;

9705: end if;
9706:
9707: EXCEPTION
9708: WHEN OTHERS THEN
9709: RAISE FND_API.G_EXC_ERROR;
9710: END;
9711:
9712: END LOOP;
9713:

Line 9725: if P_COMMIT = FND_API.G_TRUE then

9721: LogMessage(FND_LOG.LEVEL_UNEXPECTED, '______________');
9722: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Successfully applied ' || l_rc_count || ' receipts to ' || l_inv_count || ' invoices');
9723: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Number of applications: ' || l_application);
9724:
9725: if P_COMMIT = FND_API.G_TRUE then
9726: COMMIT WORK;
9727: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Commited');
9728: end if;
9729:

Line 9731: x_return_status := FND_API.G_RET_STS_SUCCESS;

9727: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Commited');
9728: end if;
9729:
9730: -- END OF BODY OF API
9731: x_return_status := FND_API.G_RET_STS_SUCCESS;
9732:
9733: -- Standard call to get message count and if count is 1, get message info
9734: FND_MSG_PUB.Count_And_Get(
9735: p_encoded => FND_API.G_FALSE,

Line 9735: p_encoded => FND_API.G_FALSE,

9731: x_return_status := FND_API.G_RET_STS_SUCCESS;
9732:
9733: -- Standard call to get message count and if count is 1, get message info
9734: FND_MSG_PUB.Count_And_Get(
9735: p_encoded => FND_API.G_FALSE,
9736: p_count => x_msg_count,
9737: p_data => x_msg_data);
9738:
9739: LogMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME || '.' || l_api_name || ' -');

Line 9742: WHEN FND_API.G_EXC_ERROR THEN

9738:
9739: LogMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME || '.' || l_api_name || ' -');
9740:
9741: EXCEPTION
9742: WHEN FND_API.G_EXC_ERROR THEN
9743: ROLLBACK TO PAY_INSTALLMENTS;
9744: x_return_status := FND_API.G_RET_STS_ERROR;
9745: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
9746: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Rollbacked');

Line 9744: x_return_status := FND_API.G_RET_STS_ERROR;

9740:
9741: EXCEPTION
9742: WHEN FND_API.G_EXC_ERROR THEN
9743: ROLLBACK TO PAY_INSTALLMENTS;
9744: x_return_status := FND_API.G_RET_STS_ERROR;
9745: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
9746: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Rollbacked');
9747: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
9748: ROLLBACK TO PAY_INSTALLMENTS;

Line 9747: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN

9743: ROLLBACK TO PAY_INSTALLMENTS;
9744: x_return_status := FND_API.G_RET_STS_ERROR;
9745: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
9746: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Rollbacked');
9747: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
9748: ROLLBACK TO PAY_INSTALLMENTS;
9749: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
9750: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
9751: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Rollbacked');

Line 9749: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;

9745: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
9746: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Rollbacked');
9747: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
9748: ROLLBACK TO PAY_INSTALLMENTS;
9749: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
9750: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
9751: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Rollbacked');
9752: WHEN OTHERS THEN
9753: ROLLBACK TO PAY_INSTALLMENTS;

Line 9754: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;

9750: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
9751: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Rollbacked');
9752: WHEN OTHERS THEN
9753: ROLLBACK TO PAY_INSTALLMENTS;
9754: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
9755: IF FND_MSG_PUB.Check_Msg_Level(FND_MSG_PUB.G_MSG_LVL_UNEXP_ERROR)THEN
9756: FND_MSG_PUB.Add_Exc_Msg(G_PKG_NAME, l_api_name);
9757: END IF;
9758: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);

Line 9858: RAISE FND_API.G_EXC_ERROR;

9854: -- LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'ERROR: Loan must be set.');
9855: FND_MESSAGE.SET_NAME('LNS', 'LNS_NO_LOAN');
9856: FND_MSG_PUB.Add;
9857: LogMessage(FND_LOG.LEVEL_UNEXPECTED, FND_MSG_PUB.Get(p_encoded => 'F'));
9858: RAISE FND_API.G_EXC_ERROR;
9859:
9860: end if;
9861:
9862: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Checking the Disable_billing_flag in '||l_api_name);

Line 9890: P_INIT_MSG_LIST => FND_API.G_TRUE,

9886:
9887: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Calling CALC_SINGLE_LOAN_NEXT_DD...');
9888: CALC_SINGLE_LOAN_NEXT_DD(
9889: P_API_VERSION => 1.0,
9890: P_INIT_MSG_LIST => FND_API.G_TRUE,
9891: P_COMMIT => FND_API.G_FALSE,
9892: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,
9893: P_LOAN_NEXT_DD_REC => l_loans_next_dd_rec,
9894: X_RETURN_STATUS => l_return_status,

Line 9891: P_COMMIT => FND_API.G_FALSE,

9887: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Calling CALC_SINGLE_LOAN_NEXT_DD...');
9888: CALC_SINGLE_LOAN_NEXT_DD(
9889: P_API_VERSION => 1.0,
9890: P_INIT_MSG_LIST => FND_API.G_TRUE,
9891: P_COMMIT => FND_API.G_FALSE,
9892: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,
9893: P_LOAN_NEXT_DD_REC => l_loans_next_dd_rec,
9894: X_RETURN_STATUS => l_return_status,
9895: X_MSG_COUNT => l_msg_count,

Line 9892: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,

9888: CALC_SINGLE_LOAN_NEXT_DD(
9889: P_API_VERSION => 1.0,
9890: P_INIT_MSG_LIST => FND_API.G_TRUE,
9891: P_COMMIT => FND_API.G_FALSE,
9892: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,
9893: P_LOAN_NEXT_DD_REC => l_loans_next_dd_rec,
9894: X_RETURN_STATUS => l_return_status,
9895: X_MSG_COUNT => l_msg_count,
9896: X_MSG_DATA => l_msg_data);

Line 9905: RAISE FND_API.G_EXC_ERROR;

9901: -- LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'ERROR: Failed to calculate next payment due date.');
9902: FND_MESSAGE.SET_NAME('LNS', 'LNS_CALC_NEXT_DUE_FAIL');
9903: FND_MSG_PUB.Add;
9904: LogMessage(FND_LOG.LEVEL_UNEXPECTED, FND_MSG_PUB.Get(p_encoded => 'F'));
9905: RAISE FND_API.G_EXC_ERROR;
9906: END IF;
9907:
9908: end if;
9909:

Line 10036: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version, l_api_name, G_PKG_NAME) THEN

10032: SAVEPOINT GET_BILLED_INSTALLMENT;
10033: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Savepoint is established');
10034:
10035: -- Standard call to check for call compatibility
10036: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version, l_api_name, G_PKG_NAME) THEN
10037: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
10038: END IF;
10039:
10040: -- Initialize message list if p_init_msg_list is set to TRUE

Line 10037: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;

10033: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Savepoint is established');
10034:
10035: -- Standard call to check for call compatibility
10036: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version, l_api_name, G_PKG_NAME) THEN
10037: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
10038: END IF;
10039:
10040: -- Initialize message list if p_init_msg_list is set to TRUE
10041: IF FND_API.To_Boolean(p_init_msg_list) THEN

Line 10041: IF FND_API.To_Boolean(p_init_msg_list) THEN

10037: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
10038: END IF;
10039:
10040: -- Initialize message list if p_init_msg_list is set to TRUE
10041: IF FND_API.To_Boolean(p_init_msg_list) THEN
10042: FND_MSG_PUB.initialize;
10043: END IF;
10044:
10045: -- Initialize API return status to success

Line 10046: X_RETURN_STATUS := FND_API.G_RET_STS_SUCCESS;

10042: FND_MSG_PUB.initialize;
10043: END IF;
10044:
10045: -- Initialize API return status to success
10046: X_RETURN_STATUS := FND_API.G_RET_STS_SUCCESS;
10047:
10048: -- START OF BODY OF API
10049: init;
10050:

Line 10062: RAISE FND_API.G_EXC_ERROR;

10058: -- LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'ERROR: Loan must be set.');
10059: FND_MESSAGE.SET_NAME('LNS', 'LNS_NO_LOAN');
10060: FND_MSG_PUB.Add;
10061: LogMessage(FND_LOG.LEVEL_UNEXPECTED, FND_MSG_PUB.Get(p_encoded => 'F'));
10062: RAISE FND_API.G_EXC_ERROR;
10063:
10064: end if;
10065:
10066: i := 0;

Line 10097: if P_COMMIT = FND_API.G_TRUE then

10093:
10094: END LOOP;
10095: close invoices_cur;
10096:
10097: if P_COMMIT = FND_API.G_TRUE then
10098: COMMIT WORK;
10099: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Commited');
10100: end if;
10101:

Line 10103: x_return_status := FND_API.G_RET_STS_SUCCESS;

10099: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Commited');
10100: end if;
10101:
10102: -- END OF BODY OF API
10103: x_return_status := FND_API.G_RET_STS_SUCCESS;
10104:
10105: -- Standard call to get message count and if count is 1, get message info
10106: FND_MSG_PUB.Count_And_Get(
10107: p_encoded => FND_API.G_FALSE,

Line 10107: p_encoded => FND_API.G_FALSE,

10103: x_return_status := FND_API.G_RET_STS_SUCCESS;
10104:
10105: -- Standard call to get message count and if count is 1, get message info
10106: FND_MSG_PUB.Count_And_Get(
10107: p_encoded => FND_API.G_FALSE,
10108: p_count => x_msg_count,
10109: p_data => x_msg_data);
10110:
10111: LogMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME || '.' || l_api_name || ' -');

Line 10114: WHEN FND_API.G_EXC_ERROR THEN

10110:
10111: LogMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME || '.' || l_api_name || ' -');
10112:
10113: EXCEPTION
10114: WHEN FND_API.G_EXC_ERROR THEN
10115: ROLLBACK TO GET_BILLED_INSTALLMENT;
10116: x_return_status := FND_API.G_RET_STS_ERROR;
10117: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
10118: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Rollbacked');

Line 10116: x_return_status := FND_API.G_RET_STS_ERROR;

10112:
10113: EXCEPTION
10114: WHEN FND_API.G_EXC_ERROR THEN
10115: ROLLBACK TO GET_BILLED_INSTALLMENT;
10116: x_return_status := FND_API.G_RET_STS_ERROR;
10117: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
10118: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Rollbacked');
10119: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
10120: ROLLBACK TO GET_BILLED_INSTALLMENT;

Line 10119: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN

10115: ROLLBACK TO GET_BILLED_INSTALLMENT;
10116: x_return_status := FND_API.G_RET_STS_ERROR;
10117: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
10118: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Rollbacked');
10119: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
10120: ROLLBACK TO GET_BILLED_INSTALLMENT;
10121: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
10122: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
10123: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Rollbacked');

Line 10121: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;

10117: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
10118: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Rollbacked');
10119: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
10120: ROLLBACK TO GET_BILLED_INSTALLMENT;
10121: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
10122: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
10123: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Rollbacked');
10124: WHEN OTHERS THEN
10125: ROLLBACK TO GET_BILLED_INSTALLMENT;

Line 10126: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;

10122: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
10123: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Rollbacked');
10124: WHEN OTHERS THEN
10125: ROLLBACK TO GET_BILLED_INSTALLMENT;
10126: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
10127: IF FND_MSG_PUB.Check_Msg_Level(FND_MSG_PUB.G_MSG_LVL_UNEXP_ERROR)THEN
10128: FND_MSG_PUB.Add_Exc_Msg(G_PKG_NAME, l_api_name);
10129: END IF;
10130: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);

Line 10225: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version, l_api_name, G_PKG_NAME) THEN

10221: SAVEPOINT BILL_AND_PAY_OFFCYCLE_BILLS;
10222: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Savepoint is established');
10223:
10224: -- Standard call to check for call compatibility
10225: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version, l_api_name, G_PKG_NAME) THEN
10226: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
10227: END IF;
10228:
10229: -- Initialize message list if p_init_msg_list is set to TRUE

Line 10226: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;

10222: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Savepoint is established');
10223:
10224: -- Standard call to check for call compatibility
10225: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version, l_api_name, G_PKG_NAME) THEN
10226: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
10227: END IF;
10228:
10229: -- Initialize message list if p_init_msg_list is set to TRUE
10230: IF FND_API.To_Boolean(p_init_msg_list) THEN

Line 10230: IF FND_API.To_Boolean(p_init_msg_list) THEN

10226: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
10227: END IF;
10228:
10229: -- Initialize message list if p_init_msg_list is set to TRUE
10230: IF FND_API.To_Boolean(p_init_msg_list) THEN
10231: FND_MSG_PUB.initialize;
10232: END IF;
10233:
10234: -- Initialize API return status to success

Line 10235: X_RETURN_STATUS := FND_API.G_RET_STS_SUCCESS;

10231: FND_MSG_PUB.initialize;
10232: END IF;
10233:
10234: -- Initialize API return status to success
10235: X_RETURN_STATUS := FND_API.G_RET_STS_SUCCESS;
10236:
10237: -- START OF BODY OF API
10238: init;
10239:

Line 10250: RAISE FND_API.G_EXC_ERROR;

10246: -- LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'ERROR: Loan must be set.');
10247: FND_MESSAGE.SET_NAME('LNS', 'LNS_NO_LOAN');
10248: FND_MSG_PUB.Add;
10249: LogMessage(FND_LOG.LEVEL_UNEXPECTED, FND_MSG_PUB.Get(p_encoded => 'F'));
10250: RAISE FND_API.G_EXC_ERROR;
10251:
10252: end if;
10253:
10254: -- get last billed amortization_schedule_id

Line 10266: P_INIT_MSG_LIST => FND_API.G_TRUE,

10262:
10263: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Calling CREATE_OFFCYCLE_BILLS...');
10264: LNS_BILLING_BATCH_PUB.CREATE_OFFCYCLE_BILLS(
10265: P_API_VERSION => 1.0,
10266: P_INIT_MSG_LIST => FND_API.G_TRUE,
10267: P_COMMIT => FND_API.G_FALSE,
10268: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,
10269: P_BILL_HEADERS_TBL => P_BILL_HEADERS_TBL,
10270: P_BILL_LINES_TBL => P_BILL_LINES_TBL,

Line 10267: P_COMMIT => FND_API.G_FALSE,

10263: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Calling CREATE_OFFCYCLE_BILLS...');
10264: LNS_BILLING_BATCH_PUB.CREATE_OFFCYCLE_BILLS(
10265: P_API_VERSION => 1.0,
10266: P_INIT_MSG_LIST => FND_API.G_TRUE,
10267: P_COMMIT => FND_API.G_FALSE,
10268: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,
10269: P_BILL_HEADERS_TBL => P_BILL_HEADERS_TBL,
10270: P_BILL_LINES_TBL => P_BILL_LINES_TBL,
10271: X_RETURN_STATUS => l_return_status,

Line 10268: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,

10264: LNS_BILLING_BATCH_PUB.CREATE_OFFCYCLE_BILLS(
10265: P_API_VERSION => 1.0,
10266: P_INIT_MSG_LIST => FND_API.G_TRUE,
10267: P_COMMIT => FND_API.G_FALSE,
10268: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,
10269: P_BILL_HEADERS_TBL => P_BILL_HEADERS_TBL,
10270: P_BILL_LINES_TBL => P_BILL_LINES_TBL,
10271: X_RETURN_STATUS => l_return_status,
10272: X_MSG_COUNT => l_msg_count,

Line 10278: RAISE FND_API.G_EXC_ERROR;

10274:
10275: IF l_return_status = 'S' THEN
10276: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Successfully billed offcycle bills.');
10277: ELSE
10278: RAISE FND_API.G_EXC_ERROR;
10279: END IF;
10280:
10281: if P_CASH_RECEIPTS_TBL.count > 0 then
10282:

Line 10300: P_INIT_MSG_LIST => FND_API.G_TRUE,

10296:
10297: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Calling PAY_INSTALLMENTS...');
10298: PAY_INSTALLMENTS(
10299: P_API_VERSION => 1.0,
10300: P_INIT_MSG_LIST => FND_API.G_TRUE,
10301: P_COMMIT => FND_API.G_FALSE,
10302: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,
10303: P_LOAN_ID => P_LOAN_ID,
10304: P_AM_SCHED_TBL => l_am_scheds_tbl,

Line 10301: P_COMMIT => FND_API.G_FALSE,

10297: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Calling PAY_INSTALLMENTS...');
10298: PAY_INSTALLMENTS(
10299: P_API_VERSION => 1.0,
10300: P_INIT_MSG_LIST => FND_API.G_TRUE,
10301: P_COMMIT => FND_API.G_FALSE,
10302: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,
10303: P_LOAN_ID => P_LOAN_ID,
10304: P_AM_SCHED_TBL => l_am_scheds_tbl,
10305: P_CASH_RECEIPTS_TBL => P_CASH_RECEIPTS_TBL,

Line 10302: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,

10298: PAY_INSTALLMENTS(
10299: P_API_VERSION => 1.0,
10300: P_INIT_MSG_LIST => FND_API.G_TRUE,
10301: P_COMMIT => FND_API.G_FALSE,
10302: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,
10303: P_LOAN_ID => P_LOAN_ID,
10304: P_AM_SCHED_TBL => l_am_scheds_tbl,
10305: P_CASH_RECEIPTS_TBL => P_CASH_RECEIPTS_TBL,
10306: X_RETURN_STATUS => l_return_status,

Line 10313: RAISE FND_API.G_EXC_ERROR;

10309:
10310: IF l_return_status = 'S' THEN
10311: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Successfully applied cash receipts.');
10312: ELSE
10313: RAISE FND_API.G_EXC_ERROR;
10314: END IF;
10315:
10316: end if;
10317:

Line 10318: if P_COMMIT = FND_API.G_TRUE then

10314: END IF;
10315:
10316: end if;
10317:
10318: if P_COMMIT = FND_API.G_TRUE then
10319: COMMIT WORK;
10320: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Commited');
10321: end if;
10322:

Line 10324: x_return_status := FND_API.G_RET_STS_SUCCESS;

10320: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Commited');
10321: end if;
10322:
10323: -- END OF BODY OF API
10324: x_return_status := FND_API.G_RET_STS_SUCCESS;
10325:
10326: -- Standard call to get message count and if count is 1, get message info
10327: FND_MSG_PUB.Count_And_Get(
10328: p_encoded => FND_API.G_FALSE,

Line 10328: p_encoded => FND_API.G_FALSE,

10324: x_return_status := FND_API.G_RET_STS_SUCCESS;
10325:
10326: -- Standard call to get message count and if count is 1, get message info
10327: FND_MSG_PUB.Count_And_Get(
10328: p_encoded => FND_API.G_FALSE,
10329: p_count => x_msg_count,
10330: p_data => x_msg_data);
10331:
10332: LogMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME || '.' || l_api_name || ' -');

Line 10335: WHEN FND_API.G_EXC_ERROR THEN

10331:
10332: LogMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME || '.' || l_api_name || ' -');
10333:
10334: EXCEPTION
10335: WHEN FND_API.G_EXC_ERROR THEN
10336: ROLLBACK TO BILL_AND_PAY_OFFCYCLE_BILLS;
10337: x_return_status := FND_API.G_RET_STS_ERROR;
10338: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
10339: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Rollbacked');

Line 10337: x_return_status := FND_API.G_RET_STS_ERROR;

10333:
10334: EXCEPTION
10335: WHEN FND_API.G_EXC_ERROR THEN
10336: ROLLBACK TO BILL_AND_PAY_OFFCYCLE_BILLS;
10337: x_return_status := FND_API.G_RET_STS_ERROR;
10338: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
10339: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Rollbacked');
10340: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
10341: ROLLBACK TO BILL_AND_PAY_OFFCYCLE_BILLS;

Line 10340: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN

10336: ROLLBACK TO BILL_AND_PAY_OFFCYCLE_BILLS;
10337: x_return_status := FND_API.G_RET_STS_ERROR;
10338: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
10339: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Rollbacked');
10340: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
10341: ROLLBACK TO BILL_AND_PAY_OFFCYCLE_BILLS;
10342: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
10343: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
10344: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Rollbacked');

Line 10342: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;

10338: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
10339: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Rollbacked');
10340: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
10341: ROLLBACK TO BILL_AND_PAY_OFFCYCLE_BILLS;
10342: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
10343: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
10344: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Rollbacked');
10345: WHEN OTHERS THEN
10346: ROLLBACK TO BILL_AND_PAY_OFFCYCLE_BILLS;

Line 10347: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;

10343: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
10344: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Rollbacked');
10345: WHEN OTHERS THEN
10346: ROLLBACK TO BILL_AND_PAY_OFFCYCLE_BILLS;
10347: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
10348: IF FND_MSG_PUB.Check_Msg_Level(FND_MSG_PUB.G_MSG_LVL_UNEXP_ERROR)THEN
10349: FND_MSG_PUB.Add_Exc_Msg(G_PKG_NAME, l_api_name);
10350: END IF;
10351: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);

Line 10455: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version, l_api_name, G_PKG_NAME) THEN

10451: SAVEPOINT BILL_SING_LOAN_SUBMIT_APPR_FEE;
10452: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Savepoint is established');
10453:
10454: -- Standard call to check for call compatibility
10455: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version, l_api_name, G_PKG_NAME) THEN
10456: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
10457: END IF;
10458:
10459: -- Initialize message list if p_init_msg_list is set to TRUE

Line 10456: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;

10452: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Savepoint is established');
10453:
10454: -- Standard call to check for call compatibility
10455: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version, l_api_name, G_PKG_NAME) THEN
10456: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
10457: END IF;
10458:
10459: -- Initialize message list if p_init_msg_list is set to TRUE
10460: IF FND_API.To_Boolean(p_init_msg_list) THEN

Line 10460: IF FND_API.To_Boolean(p_init_msg_list) THEN

10456: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
10457: END IF;
10458:
10459: -- Initialize message list if p_init_msg_list is set to TRUE
10460: IF FND_API.To_Boolean(p_init_msg_list) THEN
10461: FND_MSG_PUB.initialize;
10462: END IF;
10463:
10464: -- Initialize API return status to success

Line 10465: l_return_status := FND_API.G_RET_STS_SUCCESS;

10461: FND_MSG_PUB.initialize;
10462: END IF;
10463:
10464: -- Initialize API return status to success
10465: l_return_status := FND_API.G_RET_STS_SUCCESS;
10466:
10467: -- START OF BODY OF API
10468: l_installment_num := 0;
10469:

Line 10477: RAISE FND_API.G_EXC_ERROR;

10473: if P_LOAN_ID is null then
10474: FND_MESSAGE.SET_NAME('LNS', 'LNS_NO_LOAN');
10475: FND_MSG_PUB.Add;
10476: LogMessage(FND_LOG.LEVEL_UNEXPECTED, FND_MSG_PUB.Get(p_encoded => 'F'));
10477: RAISE FND_API.G_EXC_ERROR;
10478: end if;
10479:
10480: /* getting loan_number */
10481: open loan_cur(P_LOAN_ID);

Line 10491: LNS_FEE_ENGINE.getSubmitForApprFeeSchedule(p_init_msg_list => FND_API.G_TRUE,

10487: /*
10488: -- get UnBilled 'Submit For Approval' Fees using getSubmitForApprFeeSchedule
10489: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Calling LNS_FEES_ENGINE.getSubmitForApprFeeSchedule for Unbilled fees...');
10490:
10491: LNS_FEE_ENGINE.getSubmitForApprFeeSchedule(p_init_msg_list => FND_API.G_TRUE,
10492: p_loan_Id => P_LOAN_ID,
10493: p_billed_flag => 'N',
10494: x_fees_tbl => l_fee_tbl,
10495: X_RETURN_STATUS => l_return_status,

Line 10504: RAISE FND_API.G_EXC_ERROR;

10500: LogMessage(FND_LOG.LEVEL_STATEMENT, 'l_msg_data: ' || substr(l_msg_data,1,225));
10501:
10502: if l_return_status <> 'S' then
10503: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Failed in API LNS_FEES_ENGINE.getSubmitForApprFeeSchedule');
10504: RAISE FND_API.G_EXC_ERROR;
10505: end if;
10506: */
10507:
10508: logMessage(FND_LOG.LEVEL_PROCEDURE, 'Processing origination submit for approval fees...');

Line 10538: lns_fee_engine.processFees(p_init_msg_list => FND_API.G_TRUE

10534: l_fee_basis_tbl(8).fee_basis_amount := 0;
10535: l_fee_basis_tbl(9).fee_basis_name := 'CURR_LOAN';
10536: l_fee_basis_tbl(9).fee_basis_amount := 0;
10537:
10538: lns_fee_engine.processFees(p_init_msg_list => FND_API.G_TRUE
10539: ,p_commit => FND_API.G_FALSE
10540: ,p_loan_id => P_LOAN_ID
10541: ,p_installment_number => 0
10542: ,p_fee_basis_tbl => l_fee_basis_tbl

Line 10539: ,p_commit => FND_API.G_FALSE

10535: l_fee_basis_tbl(9).fee_basis_name := 'CURR_LOAN';
10536: l_fee_basis_tbl(9).fee_basis_amount := 0;
10537:
10538: lns_fee_engine.processFees(p_init_msg_list => FND_API.G_TRUE
10539: ,p_commit => FND_API.G_FALSE
10540: ,p_loan_id => P_LOAN_ID
10541: ,p_installment_number => 0
10542: ,p_fee_basis_tbl => l_fee_basis_tbl
10543: ,p_fee_structures => l_fee_structures

Line 10551: if l_return_status <> FND_API.G_RET_STS_SUCCESS then

10547: ,x_msg_data => l_msg_data);
10548:
10549: LogMessage(FND_LOG.LEVEL_STATEMENT, 'l_return_status: ' || l_return_status);
10550: LogMessage(FND_LOG.LEVEL_STATEMENT, 'l_msg_data: ' || substr(l_msg_data,1,225));
10551: if l_return_status <> FND_API.G_RET_STS_SUCCESS then
10552: FND_MESSAGE.SET_NAME('LNS', 'LNS_PROCESS_FEE_ERROR');
10553: FND_MSG_PUB.ADD;
10554: RAISE FND_API.G_EXC_ERROR;
10555: end if;

Line 10554: RAISE FND_API.G_EXC_ERROR;

10550: LogMessage(FND_LOG.LEVEL_STATEMENT, 'l_msg_data: ' || substr(l_msg_data,1,225));
10551: if l_return_status <> FND_API.G_RET_STS_SUCCESS then
10552: FND_MESSAGE.SET_NAME('LNS', 'LNS_PROCESS_FEE_ERROR');
10553: FND_MSG_PUB.ADD;
10554: RAISE FND_API.G_EXC_ERROR;
10555: end if;
10556:
10557: logMessage(FND_LOG.LEVEL_PROCEDURE, 'Calling lns_fee_engine.getFeeSchedule...');
10558: l_fee_tbl.delete;

Line 10559: lns_fee_engine.getFeeSchedule(p_init_msg_list => FND_API.G_TRUE

10555: end if;
10556:
10557: logMessage(FND_LOG.LEVEL_PROCEDURE, 'Calling lns_fee_engine.getFeeSchedule...');
10558: l_fee_tbl.delete;
10559: lns_fee_engine.getFeeSchedule(p_init_msg_list => FND_API.G_TRUE
10560: ,p_loan_id => P_LOAN_ID
10561: ,p_installment_number => 0
10562: ,p_disb_header_id => null
10563: ,p_phase => l_current_phase

Line 10571: if l_return_status <> FND_API.G_RET_STS_SUCCESS then

10567: ,x_msg_data => l_msg_data);
10568:
10569: LogMessage(FND_LOG.LEVEL_STATEMENT, 'l_return_status: ' || l_return_status);
10570: LogMessage(FND_LOG.LEVEL_STATEMENT, 'l_msg_data: ' || substr(l_msg_data,1,225));
10571: if l_return_status <> FND_API.G_RET_STS_SUCCESS then
10572: FND_MESSAGE.SET_NAME('LNS', 'LNS_READ_FEE_ERROR');
10573: FND_MSG_PUB.ADD;
10574: RAISE FND_API.G_EXC_ERROR;
10575: end if;

Line 10574: RAISE FND_API.G_EXC_ERROR;

10570: LogMessage(FND_LOG.LEVEL_STATEMENT, 'l_msg_data: ' || substr(l_msg_data,1,225));
10571: if l_return_status <> FND_API.G_RET_STS_SUCCESS then
10572: FND_MESSAGE.SET_NAME('LNS', 'LNS_READ_FEE_ERROR');
10573: FND_MSG_PUB.ADD;
10574: RAISE FND_API.G_EXC_ERROR;
10575: end if;
10576:
10577: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Toal No. of UnBilled SubmitApproval Fees are: ' || l_fee_tbl.count);
10578:

Line 10633: P_INIT_MSG_LIST => FND_API.G_TRUE,

10629: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Calling LNS_BILLING_BATCH_PUB.CREATE_OFFCYCLE_BILLS...');
10630:
10631: LNS_BILLING_BATCH_PUB.CREATE_OFFCYCLE_BILLS(
10632: P_API_VERSION => 1.0,
10633: P_INIT_MSG_LIST => FND_API.G_TRUE,
10634: P_COMMIT => FND_API.G_FALSE,
10635: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,
10636: P_BILL_HEADERS_TBL => l_BILL_HEADERS_TBL,
10637: P_BILL_LINES_TBL => l_BILL_LINES_TBL,

Line 10634: P_COMMIT => FND_API.G_FALSE,

10630:
10631: LNS_BILLING_BATCH_PUB.CREATE_OFFCYCLE_BILLS(
10632: P_API_VERSION => 1.0,
10633: P_INIT_MSG_LIST => FND_API.G_TRUE,
10634: P_COMMIT => FND_API.G_FALSE,
10635: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,
10636: P_BILL_HEADERS_TBL => l_BILL_HEADERS_TBL,
10637: P_BILL_LINES_TBL => l_BILL_LINES_TBL,
10638: x_return_status => l_return_status,

Line 10635: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,

10631: LNS_BILLING_BATCH_PUB.CREATE_OFFCYCLE_BILLS(
10632: P_API_VERSION => 1.0,
10633: P_INIT_MSG_LIST => FND_API.G_TRUE,
10634: P_COMMIT => FND_API.G_FALSE,
10635: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,
10636: P_BILL_HEADERS_TBL => l_BILL_HEADERS_TBL,
10637: P_BILL_LINES_TBL => l_BILL_LINES_TBL,
10638: x_return_status => l_return_status,
10639: x_msg_count => l_msg_count,

Line 10645: RAISE FND_API.G_EXC_ERROR;

10641:
10642: LogMessage(FND_LOG.LEVEL_STATEMENT, 'l_return_status: ' || l_return_status);
10643:
10644: if l_return_status <> 'S' then
10645: RAISE FND_API.G_EXC_ERROR;
10646: end if;
10647:
10648: if P_COMMIT = FND_API.G_TRUE then
10649: COMMIT WORK;

Line 10648: if P_COMMIT = FND_API.G_TRUE then

10644: if l_return_status <> 'S' then
10645: RAISE FND_API.G_EXC_ERROR;
10646: end if;
10647:
10648: if P_COMMIT = FND_API.G_TRUE then
10649: COMMIT WORK;
10650: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Commited');
10651: end if;
10652:

Line 10656: x_return_status := FND_API.G_RET_STS_SUCCESS;

10652:
10653: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Successfully billed At Submit For Approval Fee at 0-th installment for loan ' || l_loan_number);
10654:
10655: -- END OF BODY OF API
10656: x_return_status := FND_API.G_RET_STS_SUCCESS;
10657: X_BILLED_YN := 'Y';
10658:
10659: -- Standard call to get message count and if count is 1, get message info
10660: FND_MSG_PUB.Count_And_Get(

Line 10661: p_encoded => FND_API.G_FALSE,

10657: X_BILLED_YN := 'Y';
10658:
10659: -- Standard call to get message count and if count is 1, get message info
10660: FND_MSG_PUB.Count_And_Get(
10661: p_encoded => FND_API.G_FALSE,
10662: p_count => x_msg_count,
10663: p_data => x_msg_data);
10664:
10665: LogMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME || '.' || l_api_name || ' -');

Line 10668: WHEN FND_API.G_EXC_ERROR THEN

10664:
10665: LogMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME || '.' || l_api_name || ' -');
10666:
10667: EXCEPTION
10668: WHEN FND_API.G_EXC_ERROR THEN
10669: ROLLBACK TO BILL_SING_LOAN_SUBMIT_APPR_FEE;
10670: x_return_status := FND_API.G_RET_STS_ERROR;
10671: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
10672: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Rollbacked');

Line 10670: x_return_status := FND_API.G_RET_STS_ERROR;

10666:
10667: EXCEPTION
10668: WHEN FND_API.G_EXC_ERROR THEN
10669: ROLLBACK TO BILL_SING_LOAN_SUBMIT_APPR_FEE;
10670: x_return_status := FND_API.G_RET_STS_ERROR;
10671: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
10672: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Rollbacked');
10673: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
10674: ROLLBACK TO BILL_SING_LOAN_SUBMIT_APPR_FEE;

Line 10673: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN

10669: ROLLBACK TO BILL_SING_LOAN_SUBMIT_APPR_FEE;
10670: x_return_status := FND_API.G_RET_STS_ERROR;
10671: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
10672: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Rollbacked');
10673: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
10674: ROLLBACK TO BILL_SING_LOAN_SUBMIT_APPR_FEE;
10675: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
10676: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
10677: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Rollbacked');

Line 10675: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;

10671: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
10672: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Rollbacked');
10673: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
10674: ROLLBACK TO BILL_SING_LOAN_SUBMIT_APPR_FEE;
10675: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
10676: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
10677: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Rollbacked');
10678: WHEN OTHERS THEN
10679: ROLLBACK TO BILL_SING_LOAN_SUBMIT_APPR_FEE;

Line 10680: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;

10676: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
10677: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Rollbacked');
10678: WHEN OTHERS THEN
10679: ROLLBACK TO BILL_SING_LOAN_SUBMIT_APPR_FEE;
10680: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
10681: IF FND_MSG_PUB.Check_Msg_Level(FND_MSG_PUB.G_MSG_LVL_UNEXP_ERROR)THEN
10682: FND_MSG_PUB.Add_Exc_Msg(G_PKG_NAME, l_api_name);
10683: END IF;
10684: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);

Line 10716: RAISE FND_API.G_EXC_ERROR;

10712: if P_AMORTIZATION_ID is null then
10713: FND_MESSAGE.SET_NAME('LNS', 'LNS_MAN_REV_NO_AMORT');
10714: FND_MSG_PUB.Add;
10715: LogMessage(FND_LOG.LEVEL_UNEXPECTED, FND_MSG_PUB.Get(p_encoded => 'F'));
10716: RAISE FND_API.G_EXC_ERROR;
10717: end if;
10718:
10719:
10720: l_count := 0;

Line 10816: RAISE FND_API.G_EXC_ERROR;

10812:
10813: FND_MESSAGE.SET_NAME('LNS', 'LNS_NO_LOAN');
10814: FND_MSG_PUB.Add;
10815: -- LogMessage(FND_LOG.LEVEL_UNEXPECTED, FND_MSG_PUB.Get(p_encoded => 'F'));
10816: RAISE FND_API.G_EXC_ERROR;
10817:
10818: end if;
10819:
10820: -- LogMessage(FND_LOG.LEVEL_STATEMENT, 'Getting loan details...');

Line 10961: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version, l_api_name, G_PKG_NAME) THEN

10957: SAVEPOINT ADJUST_ADD_RECEIVABLE;
10958: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Savepoint is established');
10959:
10960: -- Standard call to check for call compatibility
10961: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version, l_api_name, G_PKG_NAME) THEN
10962: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
10963: END IF;
10964:
10965: -- Initialize message list if p_init_msg_list is set to TRUE

Line 10962: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;

10958: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Savepoint is established');
10959:
10960: -- Standard call to check for call compatibility
10961: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version, l_api_name, G_PKG_NAME) THEN
10962: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
10963: END IF;
10964:
10965: -- Initialize message list if p_init_msg_list is set to TRUE
10966: IF FND_API.To_Boolean(p_init_msg_list) THEN

Line 10966: IF FND_API.To_Boolean(p_init_msg_list) THEN

10962: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
10963: END IF;
10964:
10965: -- Initialize message list if p_init_msg_list is set to TRUE
10966: IF FND_API.To_Boolean(p_init_msg_list) THEN
10967: FND_MSG_PUB.initialize;
10968: END IF;
10969:
10970: -- Initialize API return status to success

Line 10971: l_return_status := FND_API.G_RET_STS_SUCCESS;

10967: FND_MSG_PUB.initialize;
10968: END IF;
10969:
10970: -- Initialize API return status to success
10971: l_return_status := FND_API.G_RET_STS_SUCCESS;
10972:
10973: -- START OF BODY OF API
10974:
10975: init;

Line 10985: RAISE FND_API.G_EXC_ERROR;

10981:
10982: FND_MESSAGE.SET_NAME( 'LNS', 'LNS_API_MISSING_COLUMN' );
10983: FND_MESSAGE.SET_TOKEN( 'COLUMN', 'P_LOAN_LINE_ID' );
10984: LogMessage(FND_LOG.LEVEL_UNEXPECTED, FND_MSG_PUB.Get(p_encoded => 'F'));
10985: RAISE FND_API.G_EXC_ERROR;
10986:
10987: end if;
10988:
10989: /* checking for system options values required for adjustment */

Line 10995: RAISE FND_API.G_EXC_ERROR;

10991: -- LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'ERROR: Receivables activity name is not set in the system option.');
10992: FND_MESSAGE.SET_NAME('LNS', 'LNS_NO_REC_TRX_IN_SYS_OPT');
10993: FND_MSG_PUB.Add;
10994: LogMessage(FND_LOG.LEVEL_UNEXPECTED, FND_MSG_PUB.Get(p_encoded => 'F'));
10995: RAISE FND_API.G_EXC_ERROR;
10996:
10997: end if;
10998:
10999: /* querying trx, psa, loan and loan lines details */

Line 11023: RAISE FND_API.G_EXC_ERROR;

11019: if l_payment_schedule_id is null then
11020: FND_MESSAGE.SET_NAME('LNS', 'LNS_CANT_FIND_ORIG_REC');
11021: FND_MSG_PUB.Add;
11022: LogMessage(FND_LOG.LEVEL_UNEXPECTED, FND_MSG_PUB.Get(p_encoded => 'F'));
11023: RAISE FND_API.G_EXC_ERROR;
11024: end if;
11025:
11026: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Adjusting additional receivable ' || l_trx_number || 'for loan ' || l_loan_number || '...');
11027:

Line 11036: RAISE FND_API.G_EXC_ERROR;

11032: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Receivable remaining amount: ' || l_amount_due_remaining);
11033: FND_MESSAGE.SET_NAME('LNS', 'LNS_INVALID_ADJ_AMT');
11034: FND_MSG_PUB.Add;
11035: LogMessage(FND_LOG.LEVEL_UNEXPECTED, FND_MSG_PUB.Get(p_encoded => 'F'));
11036: RAISE FND_API.G_EXC_ERROR;
11037: else
11038: l_type := 'LINE';
11039: end if;
11040:

Line 11051: RAISE FND_API.G_EXC_ERROR;

11047: FND_MESSAGE.SET_NAME('LNS', 'LNS_DUPL_ADJ_ORIG_REC');
11048: FND_MESSAGE.SET_TOKEN('ADJ', l_adj_number);
11049: FND_MSG_PUB.Add;
11050: LogMessage(FND_LOG.LEVEL_UNEXPECTED, FND_MSG_PUB.Get(p_encoded => 'F'));
11051: RAISE FND_API.G_EXC_ERROR;
11052: end if;
11053:
11054: /* buld comments */
11055: l_comments := 'Loan ' || l_loan_number;

Line 11075: p_init_msg_list => FND_API.G_FALSE

11071: P_ORG_ID => l_org_id);
11072:
11073: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Updating LNS_LOAN_LINES...');
11074: LNS_LOAN_LINE_PUB.UPDATE_LINE_ADJUSTMENT_NUMBER(
11075: p_init_msg_list => FND_API.G_FALSE
11076: ,p_loan_id => l_loan_id
11077: ,p_loan_line_id => l_line_id
11078: ,p_rec_adjustment_number => l_adj_number
11079: ,p_rec_adjustment_id => l_adj_id

Line 11092: RAISE FND_API.G_EXC_ERROR;

11088: LogMessage(FND_LOG.LEVEL_STATEMENT, 'l_return_status: ' || l_return_status);
11089: IF l_return_status = 'S' THEN
11090: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Successfully updated LNS_LOAN_LINES');
11091: ELSE
11092: RAISE FND_API.G_EXC_ERROR;
11093: END IF;
11094: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Successfully created adjustment ' || l_adj_number || ' for additional receivable ' || l_trx_number);
11095:
11096: if P_COMMIT = FND_API.G_TRUE then

Line 11096: if P_COMMIT = FND_API.G_TRUE then

11092: RAISE FND_API.G_EXC_ERROR;
11093: END IF;
11094: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Successfully created adjustment ' || l_adj_number || ' for additional receivable ' || l_trx_number);
11095:
11096: if P_COMMIT = FND_API.G_TRUE then
11097: COMMIT WORK;
11098: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Commited');
11099: end if;
11100:

Line 11102: x_return_status := FND_API.G_RET_STS_SUCCESS;

11098: LogMessage(FND_LOG.LEVEL_STATEMENT, 'Commited');
11099: end if;
11100:
11101: -- END OF BODY OF API
11102: x_return_status := FND_API.G_RET_STS_SUCCESS;
11103:
11104: -- Standard call to get message count and if count is 1, get message info
11105: FND_MSG_PUB.Count_And_Get(
11106: p_encoded => FND_API.G_FALSE,

Line 11106: p_encoded => FND_API.G_FALSE,

11102: x_return_status := FND_API.G_RET_STS_SUCCESS;
11103:
11104: -- Standard call to get message count and if count is 1, get message info
11105: FND_MSG_PUB.Count_And_Get(
11106: p_encoded => FND_API.G_FALSE,
11107: p_count => x_msg_count,
11108: p_data => x_msg_data);
11109:
11110: LogMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME || '.' || l_api_name || ' -');

Line 11113: WHEN FND_API.G_EXC_ERROR THEN

11109:
11110: LogMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME || '.' || l_api_name || ' -');
11111:
11112: EXCEPTION
11113: WHEN FND_API.G_EXC_ERROR THEN
11114: ROLLBACK TO ADJUST_ADD_RECEIVABLE;
11115: x_return_status := FND_API.G_RET_STS_ERROR;
11116: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
11117: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Rollbacked');

Line 11115: x_return_status := FND_API.G_RET_STS_ERROR;

11111:
11112: EXCEPTION
11113: WHEN FND_API.G_EXC_ERROR THEN
11114: ROLLBACK TO ADJUST_ADD_RECEIVABLE;
11115: x_return_status := FND_API.G_RET_STS_ERROR;
11116: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
11117: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Rollbacked');
11118: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
11119: ROLLBACK TO ADJUST_ADD_RECEIVABLE;

Line 11118: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN

11114: ROLLBACK TO ADJUST_ADD_RECEIVABLE;
11115: x_return_status := FND_API.G_RET_STS_ERROR;
11116: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
11117: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Rollbacked');
11118: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
11119: ROLLBACK TO ADJUST_ADD_RECEIVABLE;
11120: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
11121: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
11122: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Rollbacked');

Line 11120: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;

11116: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
11117: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Rollbacked');
11118: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
11119: ROLLBACK TO ADJUST_ADD_RECEIVABLE;
11120: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
11121: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
11122: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Rollbacked');
11123: WHEN OTHERS THEN
11124: ROLLBACK TO ADJUST_ADD_RECEIVABLE;

Line 11125: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;

11121: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
11122: LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'Rollbacked');
11123: WHEN OTHERS THEN
11124: ROLLBACK TO ADJUST_ADD_RECEIVABLE;
11125: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
11126: IF FND_MSG_PUB.Check_Msg_Level(FND_MSG_PUB.G_MSG_LVL_UNEXP_ERROR)THEN
11127: FND_MSG_PUB.Add_Exc_Msg(G_PKG_NAME, l_api_name);
11128: END IF;
11129: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);