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_DISTRIBUTIONS_PUB dependencies on FND_MSG_PUB

Line 100: FND_MSG_PUB.initialize;

96: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'p_loan_id ' || p_loan_id);
97:
98: -- Initialize message list IF p_init_msg_list is set to TRUE.
99: IF FND_API.to_Boolean( p_init_msg_list ) THEN
100: FND_MSG_PUB.initialize;
101: END IF;
102:
103: -- Initialize API return status to SUCCESS
104: x_return_status := FND_API.G_RET_STS_SUCCESS;

Line 175: FND_MSG_PUB.ADD;

171: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'l_event_id = ' || l_event_id);
172:
173: IF x_return_status <> FND_API.G_RET_STS_SUCCESS THEN
174: FND_MESSAGE.SET_NAME('LNS', 'LNS_ACCOUNTING_EVENT_ERROR');
175: FND_MSG_PUB.ADD;
176: logMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
177: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
178: END IF;
179:

Line 176: logMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));

172:
173: IF x_return_status <> FND_API.G_RET_STS_SUCCESS THEN
174: FND_MESSAGE.SET_NAME('LNS', 'LNS_ACCOUNTING_EVENT_ERROR');
175: FND_MSG_PUB.ADD;
176: logMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
177: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
178: END IF;
179:
180: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'stamping new event_id on distributions');

Line 222: FND_MSG_PUB.ADD;

218:
219: x_return_status := FND_API.G_RET_STS_ERROR;
220: FND_MESSAGE.SET_NAME('LNS', 'LNS_API_OTHERS_EXCEP');
221: FND_MESSAGE.SET_TOKEN('ERROR' ,'Call to PSA_BC_XLA_PUB.Budgetary_Control failed with Status Code = ' || l_status_code);
222: FND_MSG_PUB.ADD;
223: logMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
224: RAISE FND_API.G_EXC_ERROR;
225:
226: else

Line 223: logMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));

219: x_return_status := FND_API.G_RET_STS_ERROR;
220: FND_MESSAGE.SET_NAME('LNS', 'LNS_API_OTHERS_EXCEP');
221: FND_MESSAGE.SET_TOKEN('ERROR' ,'Call to PSA_BC_XLA_PUB.Budgetary_Control failed with Status Code = ' || l_status_code);
222: FND_MSG_PUB.ADD;
223: logMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
224: RAISE FND_API.G_EXC_ERROR;
225:
226: else
227: -- caller handle success status

Line 250: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);

246: WHEN FND_API.G_EXC_ERROR THEN
247: ROLLBACK TO cancel_disbursements;
248: x_return_status := FND_API.G_RET_STS_ERROR;
249: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
250: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
251:
252: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
253: ROLLBACK TO cancel_disbursements;
254: x_return_status := FND_API.G_RET_STS_ERROR;

Line 256: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);

252: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
253: ROLLBACK TO cancel_disbursements;
254: x_return_status := FND_API.G_RET_STS_ERROR;
255: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
256: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
257:
258: WHEN OTHERS THEN
259: ROLLBACK TO cancel_disbursements;
260: x_return_status := FND_API.G_RET_STS_ERROR;

Line 262: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);

258: WHEN OTHERS THEN
259: ROLLBACK TO cancel_disbursements;
260: x_return_status := FND_API.G_RET_STS_ERROR;
261: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
262: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
263:
264: end cancel_disbursements;
265:
266: /*=========================================================================

Line 375: FND_MSG_PUB.ADD;

371: if l_return_status <> FND_API.G_RET_STS_SUCCESS then
372: FND_MESSAGE.SET_NAME('LNS', 'LNS_INVALID_VALUE');
373: FND_MESSAGE.SET_TOKEN('PARAMETER', 'LOAN_ID');
374: FND_MESSAGE.SET_TOKEN('VALUE', p_loan_id);
375: FND_MSG_PUB.ADD;
376: RAISE FND_API.G_EXC_ERROR;
377: end if;
378:
379: OPEN c_loan_adj(p_loan_id);

Line 405: FND_MSG_PUB.ADD;

401: if l_return_status <> FND_API.G_RET_STS_SUCCESS then
402: FND_MESSAGE.SET_NAME('LNS', 'LNS_INVALID_VALUE');
403: FND_MESSAGE.SET_TOKEN('PARAMETER', 'LOAN_AMOUNT_ADJ_ID');
404: FND_MESSAGE.SET_TOKEN('VALUE', p_loan_amount_adj_id);
405: FND_MSG_PUB.ADD;
406: RAISE FND_API.G_EXC_ERROR;
407: end if;
408:
409: l_loan_amount_adj_id := p_loan_amount_adj_id;

Line 572: FND_MSG_PUB.initialize;

568: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'p_budgetary_control_mode = ' || p_budgetary_control_mode);
569:
570: -- Initialize message list IF p_init_msg_list is set to TRUE.
571: IF FND_API.to_Boolean( p_init_msg_list ) THEN
572: FND_MSG_PUB.initialize;
573: END IF;
574:
575: -- Initialize API return status to SUCCESS
576: x_return_status := FND_API.G_RET_STS_SUCCESS;

Line 587: FND_MSG_PUB.ADD;

583:
584: -- Bug#6711479 We can't check funds without valid disbursement
585: IF (l_disbursement_id IS NULL) THEN
586: FND_MESSAGE.SET_NAME('LNS', 'LNS_CHK_FUND_DISB_INVALID');
587: FND_MSG_PUB.ADD;
588: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
589: FND_MESSAGE.SET_NAME('LNS', 'LNS_CREATE_DISB_SCHED');
590: FND_MSG_PUB.ADD;
591: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));

Line 588: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));

584: -- Bug#6711479 We can't check funds without valid disbursement
585: IF (l_disbursement_id IS NULL) THEN
586: FND_MESSAGE.SET_NAME('LNS', 'LNS_CHK_FUND_DISB_INVALID');
587: FND_MSG_PUB.ADD;
588: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
589: FND_MESSAGE.SET_NAME('LNS', 'LNS_CREATE_DISB_SCHED');
590: FND_MSG_PUB.ADD;
591: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
592: RAISE FND_API.G_EXC_ERROR;

Line 590: FND_MSG_PUB.ADD;

586: FND_MESSAGE.SET_NAME('LNS', 'LNS_CHK_FUND_DISB_INVALID');
587: FND_MSG_PUB.ADD;
588: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
589: FND_MESSAGE.SET_NAME('LNS', 'LNS_CREATE_DISB_SCHED');
590: FND_MSG_PUB.ADD;
591: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
592: RAISE FND_API.G_EXC_ERROR;
593: END IF;
594:

Line 591: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));

587: FND_MSG_PUB.ADD;
588: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
589: FND_MESSAGE.SET_NAME('LNS', 'LNS_CREATE_DISB_SCHED');
590: FND_MSG_PUB.ADD;
591: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
592: RAISE FND_API.G_EXC_ERROR;
593: END IF;
594:
595: if ((lns_utility_pub.IS_FED_FIN_ENABLED = 'Y' OR lns_utility_pub.IS_ENCUM_FIN_ENABLED = 'Y') AND l_disbursement_id IS NOT NULL) then

Line 631: FND_MSG_PUB.ADD;

627: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'x_event_id ' || x_event_id);
628:
629: IF x_return_status <> FND_API.G_RET_STS_SUCCESS THEN
630: FND_MESSAGE.SET_NAME('LNS', 'LNS_ACCOUNTING_EVENT_ERROR');
631: FND_MSG_PUB.ADD;
632: logMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
633: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
634: END IF;
635:

Line 632: logMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));

628:
629: IF x_return_status <> FND_API.G_RET_STS_SUCCESS THEN
630: FND_MESSAGE.SET_NAME('LNS', 'LNS_ACCOUNTING_EVENT_ERROR');
631: FND_MSG_PUB.ADD;
632: logMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
633: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
634: END IF;
635:
636: -- stamp the eventID onto the lns_distributions table

Line 707: FND_MSG_PUB.ADD;

703:
704: l_return_status := FND_API.G_RET_STS_ERROR;
705: FND_MESSAGE.SET_NAME('LNS', 'LNS_API_OTHERS_EXCEP');
706: FND_MESSAGE.SET_TOKEN('ERROR' ,'Call to PSA_BC_XLA_PUB.Budgetary_Control failed with Status Code = ' || l_status_code);
707: FND_MSG_PUB.ADD;
708: logMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
709: RAISE FND_API.G_EXC_ERROR;
710:
711: else

Line 708: logMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));

704: l_return_status := FND_API.G_RET_STS_ERROR;
705: FND_MESSAGE.SET_NAME('LNS', 'LNS_API_OTHERS_EXCEP');
706: FND_MESSAGE.SET_TOKEN('ERROR' ,'Call to PSA_BC_XLA_PUB.Budgetary_Control failed with Status Code = ' || l_status_code);
707: FND_MSG_PUB.ADD;
708: logMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
709: RAISE FND_API.G_EXC_ERROR;
710:
711: else
712: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'l_budget_req_approval = ' || l_budget_req_approval);

Line 722: FND_MSG_PUB.ADD_DETAIL(p_message_type => FND_MSG_PUB.G_WARNING_MSG );

718: x_return_status := l_return_status;
719:
720: /*
721: FND_MESSAGE.SET_NAME('LNS', 'LNS_APPROVAL_NO_BUDGET');
722: FND_MSG_PUB.ADD_DETAIL(p_message_type => FND_MSG_PUB.G_WARNING_MSG );
723: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
724: */
725:
726: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, ' BudgetReserve is not mandatory for LoanApproval, so returning to invoked method');

Line 723: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));

719:
720: /*
721: FND_MESSAGE.SET_NAME('LNS', 'LNS_APPROVAL_NO_BUDGET');
722: FND_MSG_PUB.ADD_DETAIL(p_message_type => FND_MSG_PUB.G_WARNING_MSG );
723: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
724: */
725:
726: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, ' BudgetReserve is not mandatory for LoanApproval, so returning to invoked method');
727:

Line 728: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);

724: */
725:
726: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, ' BudgetReserve is not mandatory for LoanApproval, so returning to invoked method');
727:
728: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
729:
730: return;
731:
732: end if;

Line 738: FND_MSG_PUB.ADD;

734: /*
735: if l_status_code NOT IN ('SUCCESS','ADVISORY') then
736: IF (l_status_code = 'PARTIAL') THEN
737: FND_MESSAGE.SET_NAME('LNS', 'LNS_FUND_CHK_PARTIAL');
738: FND_MSG_PUB.ADD;
739: logMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
740: RAISE FND_API.G_EXC_ERROR;
741: ELSE
742: FND_MESSAGE.SET_NAME('LNS', 'LNS_API_OTHERS_EXCEP');

Line 739: logMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));

735: if l_status_code NOT IN ('SUCCESS','ADVISORY') then
736: IF (l_status_code = 'PARTIAL') THEN
737: FND_MESSAGE.SET_NAME('LNS', 'LNS_FUND_CHK_PARTIAL');
738: FND_MSG_PUB.ADD;
739: logMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
740: RAISE FND_API.G_EXC_ERROR;
741: ELSE
742: FND_MESSAGE.SET_NAME('LNS', 'LNS_API_OTHERS_EXCEP');
743: FND_MESSAGE.SET_TOKEN('ERROR' ,'Call to PSA_BC_XLA_PUB.Budgetary_Control failed with Status Code = ' || l_status_code);

Line 744: FND_MSG_PUB.ADD;

740: RAISE FND_API.G_EXC_ERROR;
741: ELSE
742: FND_MESSAGE.SET_NAME('LNS', 'LNS_API_OTHERS_EXCEP');
743: FND_MESSAGE.SET_TOKEN('ERROR' ,'Call to PSA_BC_XLA_PUB.Budgetary_Control failed with Status Code = ' || l_status_code);
744: FND_MSG_PUB.ADD;
745: logMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
746: RAISE FND_API.G_EXC_ERROR;
747: END IF;
748: end if;

Line 745: logMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));

741: ELSE
742: FND_MESSAGE.SET_NAME('LNS', 'LNS_API_OTHERS_EXCEP');
743: FND_MESSAGE.SET_TOKEN('ERROR' ,'Call to PSA_BC_XLA_PUB.Budgetary_Control failed with Status Code = ' || l_status_code);
744: FND_MSG_PUB.ADD;
745: logMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
746: RAISE FND_API.G_EXC_ERROR;
747: END IF;
748: end if;
749: */

Line 755: FND_MSG_PUB.ADD;

751: if (l_status_code = 'ADVISORY' or l_status_code = 'SUCCESS') then
752: l_loan_header_rec.FUNDS_RESERVED_FLAG := 'Y';
753: else
754: FND_MESSAGE.SET_NAME('LNS', 'LNS_FUND_RSRV_FAILED');
755: FND_MSG_PUB.ADD;
756: logMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
757: end if;
758: end if;
759:

Line 756: logMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));

752: l_loan_header_rec.FUNDS_RESERVED_FLAG := 'Y';
753: else
754: FND_MESSAGE.SET_NAME('LNS', 'LNS_FUND_RSRV_FAILED');
755: FND_MSG_PUB.ADD;
756: logMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
757: end if;
758: end if;
759:
760: open c_obj_vers(p_loan_id);

Line 777: FND_MSG_PUB.ADD;

773: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'update loan status = ' || l_return_status);
774:
775: if l_return_status <> 'S' then
776: FND_MESSAGE.SET_NAME('LNS', 'LNS_UPD_LOAN_FAIL');
777: FND_MSG_PUB.ADD;
778: logMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
779: RAISE FND_API.G_EXC_ERROR;
780: end if;
781:

Line 778: logMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));

774:
775: if l_return_status <> 'S' then
776: FND_MESSAGE.SET_NAME('LNS', 'LNS_UPD_LOAN_FAIL');
777: FND_MSG_PUB.ADD;
778: logMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
779: RAISE FND_API.G_EXC_ERROR;
780: end if;
781:
782: end if; -- BC_API.RETURN_STATUS

Line 803: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);

799: WHEN FND_API.G_EXC_ERROR THEN
800: ROLLBACK TO budgetary_control_pvt;
801: x_return_status := FND_API.G_RET_STS_ERROR;
802: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
803: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
804:
805: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
806: ROLLBACK TO budgetary_control_pvt;
807: x_return_status := FND_API.G_RET_STS_ERROR;

Line 809: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);

805: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
806: ROLLBACK TO budgetary_control_pvt;
807: x_return_status := FND_API.G_RET_STS_ERROR;
808: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
809: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
810:
811: WHEN OTHERS THEN
812: ROLLBACK TO budgetary_control_pvt;
813: x_return_status := FND_API.G_RET_STS_ERROR;

Line 815: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);

811: WHEN OTHERS THEN
812: ROLLBACK TO budgetary_control_pvt;
813: x_return_status := FND_API.G_RET_STS_ERROR;
814: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
815: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
816:
817: end budgetary_control;
818:
819:

Line 945: FND_MSG_PUB.ADD;

941:
942: else
943:
944: FND_MESSAGE.SET_NAME('LNS', 'LNS_DEFAULT_DIST_NOT_FOUND');
945: FND_MSG_PUB.ADD;
946: logMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
947: RAISE FND_API.G_EXC_ERROR;
948:
949: end if;

Line 946: logMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));

942: else
943:
944: FND_MESSAGE.SET_NAME('LNS', 'LNS_DEFAULT_DIST_NOT_FOUND');
945: FND_MSG_PUB.ADD;
946: logMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
947: RAISE FND_API.G_EXC_ERROR;
948:
949: end if;
950: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, l_api_name || ' - END');

Line 1117: FND_MSG_PUB.initialize;

1113: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'p_distribution_type = ' || p_distribution_type);
1114:
1115: -- Initialize message list IF p_init_msg_list is set to TRUE.
1116: IF FND_API.to_Boolean( p_init_msg_list ) THEN
1117: FND_MSG_PUB.initialize;
1118: END IF;
1119:
1120: -- Initialize API return status to SUCCESS
1121: x_return_status := FND_API.G_RET_STS_SUCCESS;

Line 1336: FND_MSG_PUB.ADD;

1332:
1333: exception
1334: when no_data_found then
1335: FND_MESSAGE.SET_NAME('LNS', 'LNS_DEFAULT_DIST_NOT_FOUND');
1336: FND_MSG_PUB.ADD;
1337: logMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
1338: RAISE FND_API.G_EXC_ERROR;
1339: End; -- c_default_info cursor
1340:

Line 1337: logMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));

1333: exception
1334: when no_data_found then
1335: FND_MESSAGE.SET_NAME('LNS', 'LNS_DEFAULT_DIST_NOT_FOUND');
1336: FND_MSG_PUB.ADD;
1337: logMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
1338: RAISE FND_API.G_EXC_ERROR;
1339: End; -- c_default_info cursor
1340:
1341: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'distribs2 count is ' || l_distributions.count);

Line 1349: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);

1345: THEN
1346: COMMIT WORK;
1347: END IF;
1348:
1349: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
1350:
1351: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, l_api_name || ' - END');
1352:
1353: EXCEPTION

Line 1358: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);

1354: WHEN FND_API.G_EXC_ERROR THEN
1355: ROLLBACK TO defaultDistributionsCatch;
1356: x_return_status := FND_API.G_RET_STS_ERROR;
1357: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
1358: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
1359:
1360: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
1361: ROLLBACK TO defaultDistributionsCatch;
1362: x_return_status := FND_API.G_RET_STS_ERROR;

Line 1364: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);

1360: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
1361: ROLLBACK TO defaultDistributionsCatch;
1362: x_return_status := FND_API.G_RET_STS_ERROR;
1363: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
1364: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
1365:
1366: WHEN OTHERS THEN
1367: ROLLBACK TO defaultDistributionsCatch;
1368: x_return_status := FND_API.G_RET_STS_ERROR;

Line 1370: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);

1366: WHEN OTHERS THEN
1367: ROLLBACK TO defaultDistributionsCatch;
1368: x_return_status := FND_API.G_RET_STS_ERROR;
1369: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
1370: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
1371:
1372: end defaultDistributionsCatch;
1373:
1374:

Line 1442: FND_MSG_PUB.initialize;

1438: SAVEPOINT create_event;
1439:
1440: -- Initialize message list IF p_init_msg_list is set to TRUE.
1441: IF FND_API.to_Boolean(p_init_msg_list) THEN
1442: FND_MSG_PUB.initialize;
1443: END IF;
1444:
1445: -- Initialize API return status to SUCCESS
1446: x_return_status := FND_API.G_RET_STS_SUCCESS;

Line 1483: FND_MSG_PUB.ADD;

1479: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'x_return_status = ' || x_return_status);
1480:
1481: IF x_return_status <> FND_API.G_RET_STS_SUCCESS THEN
1482: FND_MESSAGE.SET_NAME('LNS', 'LNS_ACCOUNTING_EVENT_ERROR');
1483: FND_MSG_PUB.ADD;
1484: logMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
1485: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
1486: ELSE
1487: -- update the distributions table with proper event_id for valid disb_header_id/loan_amount_adj_id

Line 1484: logMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));

1480:
1481: IF x_return_status <> FND_API.G_RET_STS_SUCCESS THEN
1482: FND_MESSAGE.SET_NAME('LNS', 'LNS_ACCOUNTING_EVENT_ERROR');
1483: FND_MSG_PUB.ADD;
1484: logMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
1485: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
1486: ELSE
1487: -- update the distributions table with proper event_id for valid disb_header_id/loan_amount_adj_id
1488: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Updating lns_distributions...');

Line 1523: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);

1519: end loop;
1520: -- ---------------------------------------------------------------------
1521: -- End of API body
1522: -- ---------------------------------------------------------------------
1523: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
1524:
1525: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, l_api_name || ' - END');
1526:
1527: EXCEPTION

Line 1533: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);

1529: ROLLBACK TO create_event;
1530: x_return_status := FND_API.G_RET_STS_ERROR;
1531: x_msg_count := l_msg_count;
1532: x_msg_data := l_msg_data;
1533: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
1534: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
1535:
1536: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
1537: ROLLBACK TO create_event;

Line 1541: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);

1537: ROLLBACK TO create_event;
1538: x_return_status := FND_API.G_RET_STS_ERROR;
1539: x_msg_count := l_msg_count;
1540: x_msg_data := l_msg_data;
1541: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
1542: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
1543:
1544: WHEN OTHERS THEN
1545: ROLLBACK TO create_event;

Line 1549: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);

1545: ROLLBACK TO create_event;
1546: x_return_status := FND_API.G_RET_STS_ERROR;
1547: x_msg_count := l_msg_count;
1548: x_msg_data := l_msg_data;
1549: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
1550: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
1551:
1552: end create_event;
1553:

Line 1612: FND_MSG_PUB.ADD;

1608: Exception
1609: When others then
1610: logMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'failed to retrieve replacement natural account');
1611: FND_MESSAGE.SET_NAME('LNS', 'LNS_MFAR_CONFIGURATION_ERROR');
1612: FND_MSG_PUB.ADD;
1613: logMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
1614: RAISE FND_API.G_EXC_ERROR;
1615:
1616: end getNaturalSwapAccount;

Line 1613: logMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));

1609: When others then
1610: logMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'failed to retrieve replacement natural account');
1611: FND_MESSAGE.SET_NAME('LNS', 'LNS_MFAR_CONFIGURATION_ERROR');
1612: FND_MSG_PUB.ADD;
1613: logMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
1614: RAISE FND_API.G_EXC_ERROR;
1615:
1616: end getNaturalSwapAccount;
1617:

Line 1679: FND_MSG_PUB.ADD;

1675: ,l_num_segments
1676: ,l_original_segments))
1677: Then
1678: FND_MESSAGE.SET_NAME('LNS', 'LNS_ERR_BUILDING_SEGMENTS');
1679: FND_MSG_PUB.ADD;
1680: logMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
1681: RAISE FND_API.G_EXC_ERROR;
1682: END IF;
1683:

Line 1680: logMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));

1676: ,l_original_segments))
1677: Then
1678: FND_MESSAGE.SET_NAME('LNS', 'LNS_ERR_BUILDING_SEGMENTS');
1679: FND_MSG_PUB.ADD;
1680: logMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
1681: RAISE FND_API.G_EXC_ERROR;
1682: END IF;
1683:
1684: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Original segments:');

Line 1716: FND_MSG_PUB.ADD;

1712: l_new_segments,
1713: l_new_cc_id))
1714: Then
1715: FND_MESSAGE.SET_NAME('LNS', 'LNS_CODE_COMBINATION_ERROR');
1716: FND_MSG_PUB.ADD;
1717: logMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
1718: RAISE FND_API.G_EXC_ERROR;
1719:
1720: END IF;

Line 1717: logMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));

1713: l_new_cc_id))
1714: Then
1715: FND_MESSAGE.SET_NAME('LNS', 'LNS_CODE_COMBINATION_ERROR');
1716: FND_MSG_PUB.ADD;
1717: logMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
1718: RAISE FND_API.G_EXC_ERROR;
1719:
1720: END IF;
1721: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'new cc_id = ' || l_new_cc_id);

Line 1796: FND_MSG_PUB.ADD;

1792:
1793: Exception
1794: When others then
1795: FND_MESSAGE.SET_NAME('LNS', 'LNS_MFAR_CONFIGURATION_ERROR');
1796: FND_MSG_PUB.ADD;
1797: logMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
1798: RAISE FND_API.G_EXC_ERROR;
1799: End;
1800: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'swap natural account with ' || l_natural_account_rec);

Line 1797: logMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));

1793: Exception
1794: When others then
1795: FND_MESSAGE.SET_NAME('LNS', 'LNS_MFAR_CONFIGURATION_ERROR');
1796: FND_MSG_PUB.ADD;
1797: logMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
1798: RAISE FND_API.G_EXC_ERROR;
1799: End;
1800: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'swap natural account with ' || l_natural_account_rec);
1801: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'COA ' || l_ledger_details.chart_of_accounts_id);

Line 1812: FND_MSG_PUB.ADD;

1808: ,flex_qual_name => 'GL_ACCOUNT'
1809: ,segment_number => l_nat_acct_seg_number))
1810: THEN
1811: FND_MESSAGE.SET_NAME('LNS', 'LNS_NO_NATURAL_ACCOUNT_SEGMENT');
1812: FND_MSG_PUB.ADD;
1813: logMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
1814: RAISE FND_API.G_EXC_ERROR;
1815:
1816: END IF;

Line 1813: logMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));

1809: ,segment_number => l_nat_acct_seg_number))
1810: THEN
1811: FND_MESSAGE.SET_NAME('LNS', 'LNS_NO_NATURAL_ACCOUNT_SEGMENT');
1812: FND_MSG_PUB.ADD;
1813: logMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
1814: RAISE FND_API.G_EXC_ERROR;
1815:
1816: END IF;
1817: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'natural acct segment is ' || l_nat_acct_seg_number);

Line 2557: FND_MSG_PUB.ADD;

2553:
2554: exception
2555: when others then
2556: FND_MESSAGE.SET_NAME('LNS', 'LNS_LEDGER_DETAILS_FAIL');
2557: FND_MSG_PUB.ADD;
2558: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
2559: RAISE FND_API.G_EXC_ERROR;
2560: end;
2561:

Line 2558: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));

2554: exception
2555: when others then
2556: FND_MESSAGE.SET_NAME('LNS', 'LNS_LEDGER_DETAILS_FAIL');
2557: FND_MSG_PUB.ADD;
2558: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
2559: RAISE FND_API.G_EXC_ERROR;
2560: end;
2561:
2562: end getLedgerDetails;

Line 3129: FND_MSG_PUB.initialize;

3125: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, l_api_name || ' - BEGIN');
3126:
3127: -- Initialize message list IF p_init_msg_list is set to TRUE.
3128: IF FND_API.to_Boolean( p_init_msg_list ) THEN
3129: FND_MSG_PUB.initialize;
3130: END IF;
3131:
3132: -- Initialize API return status to SUCCESS
3133: x_return_status := FND_API.G_RET_STS_SUCCESS;

Line 3262: FND_MSG_PUB.Add;

3258: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'num is: ' || l_num_receivables_acc);
3259:
3260: if l_num_receivables_acc <> l_num_receivables_ers then
3261: FND_MESSAGE.Set_Name('LNS', 'LNS_AR_RECEIVABLES_UNACC');
3262: FND_MSG_PUB.Add;
3263: RAISE FND_API.G_EXC_ERROR;
3264: end if;
3265: */
3266:

Line 3277: FND_MSG_PUB.Add;

3273: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'loan recivables origination Count = ' || l_loan_receivables_orig.count );
3274: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'loan recivables billing Count = ' || l_loan_receivables_bill.count);
3275: if l_loan_receivables_orig.count <> l_loan_receivables_bill.count then
3276: FND_MESSAGE.Set_Name('LNS', 'LNS_ACC_INVALID_RECEIVABLES');
3277: FND_MSG_PUB.Add;
3278: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
3279: RAISE FND_API.G_EXC_ERROR;
3280: end if;
3281:

Line 3278: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));

3274: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'loan recivables billing Count = ' || l_loan_receivables_bill.count);
3275: if l_loan_receivables_orig.count <> l_loan_receivables_bill.count then
3276: FND_MESSAGE.Set_Name('LNS', 'LNS_ACC_INVALID_RECEIVABLES');
3277: FND_MSG_PUB.Add;
3278: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
3279: RAISE FND_API.G_EXC_ERROR;
3280: end if;
3281:
3282: -- B. The account code combinations for the Loans Receivable accounts within

Line 3292: FND_MSG_PUB.Add;

3288: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'loan recivables origination cc_id = ' || l_loan_receivables_orig(j).code_combination_id );
3289: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'loan recivables billing cc_id = ' || l_loan_receivables_bill(j).code_combination_id);
3290: if l_loan_receivables_orig(j).code_combination_id <> l_loan_receivables_bill(j).code_combination_id then
3291: FND_MESSAGE.Set_Name('LNS', 'LNS_ACC_LOAN_REC_CCIDS_UNMATCH');
3292: FND_MSG_PUB.Add;
3293: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
3294: RAISE FND_API.G_EXC_ERROR;
3295: end if;
3296:

Line 3293: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));

3289: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'loan recivables billing cc_id = ' || l_loan_receivables_bill(j).code_combination_id);
3290: if l_loan_receivables_orig(j).code_combination_id <> l_loan_receivables_bill(j).code_combination_id then
3291: FND_MESSAGE.Set_Name('LNS', 'LNS_ACC_LOAN_REC_CCIDS_UNMATCH');
3292: FND_MSG_PUB.Add;
3293: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
3294: RAISE FND_API.G_EXC_ERROR;
3295: end if;
3296:
3297: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'checking for duplicate IDs');

Line 3303: FND_MSG_PUB.Add;

3299: if (l_loan_receivables_orig(j).code_combination_id = l_loan_receivables_orig(j+1).code_combination_id)
3300: then
3301: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'found duplicate IDs');
3302: FND_MESSAGE.Set_Name('LNS', 'LNS_UNIQUE_CC_IDS');
3303: FND_MSG_PUB.Add;
3304: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
3305: RAISE FND_API.G_EXC_ERROR;
3306: end if;
3307: end if;

Line 3304: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));

3300: then
3301: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'found duplicate IDs');
3302: FND_MESSAGE.Set_Name('LNS', 'LNS_UNIQUE_CC_IDS');
3303: FND_MSG_PUB.Add;
3304: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
3305: RAISE FND_API.G_EXC_ERROR;
3306: end if;
3307: end if;
3308:

Line 3317: FND_MSG_PUB.Add;

3313: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'loan recivables origination percent = ' || l_loan_receivables_orig(j).distribution_percent );
3314: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'loan recivables billing percent = ' || l_loan_receivables_bill(j).distribution_percent);
3315: if l_loan_receivables_orig(j).distribution_percent <> l_loan_receivables_bill(j).distribution_percent then
3316: FND_MESSAGE.Set_Name('LNS', 'LNS_ACC_LOAN_REC_PER_UNMATCH');
3317: FND_MSG_PUB.Add;
3318: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
3319: RAISE FND_API.G_EXC_ERROR;
3320: end if;
3321:

Line 3318: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));

3314: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'loan recivables billing percent = ' || l_loan_receivables_bill(j).distribution_percent);
3315: if l_loan_receivables_orig(j).distribution_percent <> l_loan_receivables_bill(j).distribution_percent then
3316: FND_MESSAGE.Set_Name('LNS', 'LNS_ACC_LOAN_REC_PER_UNMATCH');
3317: FND_MSG_PUB.Add;
3318: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
3319: RAISE FND_API.G_EXC_ERROR;
3320: end if;
3321:
3322: l_dist_percent_rec_orig := l_dist_percent_rec_orig + l_loan_receivables_orig(j).distribution_percent;

Line 3345: FND_MSG_PUB.Add;

3341: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'checking ERS Prin Billing receivables total percentages');
3342: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Prin Billing loan recivables total percent: ' || l_dist_percent_rec_bill);
3343: if l_dist_percent_rec_bill <> 100 then
3344: FND_MESSAGE.Set_Name('LNS', 'LNS_ACC_BILL_REC_PER_INVALID');
3345: FND_MSG_PUB.Add;
3346: RAISE FND_API.G_EXC_ERROR;
3347: end if;
3348:
3349:

Line 3365: FND_MSG_PUB.Add;

3361: if p < l_loan_clearing_orig.count then
3362: if (l_loan_clearing_orig(p).code_combination_id = l_loan_clearing_orig(p+1).code_combination_id) then
3363: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'found duplicate IDs');
3364: FND_MESSAGE.Set_Name('LNS', 'LNS_UNIQUE_CC_IDS');
3365: FND_MSG_PUB.Add;
3366: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
3367: RAISE FND_API.G_EXC_ERROR;
3368: end if;
3369: end if;

Line 3366: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));

3362: if (l_loan_clearing_orig(p).code_combination_id = l_loan_clearing_orig(p+1).code_combination_id) then
3363: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'found duplicate IDs');
3364: FND_MESSAGE.Set_Name('LNS', 'LNS_UNIQUE_CC_IDS');
3365: FND_MSG_PUB.Add;
3366: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
3367: RAISE FND_API.G_EXC_ERROR;
3368: end if;
3369: end if;
3370: l_dist_percent_clear_orig := l_dist_percent_clear_orig + l_loan_clearing_orig(p).distribution_percent;

Line 3382: FND_MSG_PUB.Add;

3378: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'checking origination receivables total percentages');
3379: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'loan recivables total percent = ' || l_dist_percent_rec_orig);
3380: if l_dist_percent_rec_orig <> 100 then
3381: FND_MESSAGE.Set_Name('LNS', 'LNS_ACC_ORIG_REC_PER_INVALID');
3382: FND_MSG_PUB.Add;
3383: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
3384: RAISE FND_API.G_EXC_ERROR;
3385: end if;
3386:

Line 3383: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));

3379: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'loan recivables total percent = ' || l_dist_percent_rec_orig);
3380: if l_dist_percent_rec_orig <> 100 then
3381: FND_MESSAGE.Set_Name('LNS', 'LNS_ACC_ORIG_REC_PER_INVALID');
3382: FND_MSG_PUB.Add;
3383: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
3384: RAISE FND_API.G_EXC_ERROR;
3385: end if;
3386:
3387: -- D. The distribution percentage for the Loans Clearing accounts in Origination must add to 100%

Line 3393: FND_MSG_PUB.Add;

3389: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'checking origination clearing total percentages');
3390: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'loan clearing total percent = ' || l_dist_percent_clear_orig);
3391: if l_dist_percent_clear_orig <> 100 then
3392: FND_MESSAGE.Set_Name('LNS', 'LNS_ACC_ORIG_CLR_PER_INVALID');
3393: FND_MSG_PUB.Add;
3394: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
3395: RAISE FND_API.G_EXC_ERROR;
3396: end if;
3397: END IF; -- IF (l_loan_status IN ('INCOMPLETE', 'PENDING', 'APPROVED'))

Line 3394: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));

3390: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'loan clearing total percent = ' || l_dist_percent_clear_orig);
3391: if l_dist_percent_clear_orig <> 100 then
3392: FND_MESSAGE.Set_Name('LNS', 'LNS_ACC_ORIG_CLR_PER_INVALID');
3393: FND_MSG_PUB.Add;
3394: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
3395: RAISE FND_API.G_EXC_ERROR;
3396: end if;
3397: END IF; -- IF (l_loan_status IN ('INCOMPLETE', 'PENDING', 'APPROVED'))
3398:

Line 3406: FND_MSG_PUB.Add;

3402: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'checking billing receivables total percentages');
3403: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'loan recivables total percent: ' || l_dist_percent_rec_bill);
3404: if l_dist_percent_rec_bill <> 100 then
3405: FND_MESSAGE.Set_Name('LNS', 'LNS_ACC_BILL_REC_PER_INVALID');
3406: FND_MSG_PUB.Add;
3407: RAISE FND_API.G_EXC_ERROR;
3408: end if;
3409:
3410:

Line 3417: FND_MSG_PUB.Add;

3413:
3414:
3415: if l_dist_percent_clear_orig <> 100 then
3416: FND_MESSAGE.Set_Name('LNS', 'LNS_ACC_ORIG_CLR_PER_INVALID');
3417: FND_MSG_PUB.Add;
3418: RAISE FND_API.G_EXC_ERROR;
3419: end if;
3420: */
3421: -- G. In the current release of 11i, there must be only one Principal Receivable

Line 3427: FND_MSG_PUB.Add;

3423: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'checking principal receivables count');
3424: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'principal receivables count = ' || l_prin_receivables_bill.count);
3425: if l_prin_receivables_bill.count <> 1 then
3426: FND_MESSAGE.Set_Name('LNS', 'LNS_ACC_MULT_PRIN_RECEIVABLE');
3427: FND_MSG_PUB.Add;
3428: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
3429: RAISE FND_API.G_EXC_ERROR;
3430: end if;
3431:

Line 3428: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));

3424: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'principal receivables count = ' || l_prin_receivables_bill.count);
3425: if l_prin_receivables_bill.count <> 1 then
3426: FND_MESSAGE.Set_Name('LNS', 'LNS_ACC_MULT_PRIN_RECEIVABLE');
3427: FND_MSG_PUB.Add;
3428: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
3429: RAISE FND_API.G_EXC_ERROR;
3430: end if;
3431:
3432: -- H. In the current release of 11i, there must be only one Interest Receivable

Line 3438: FND_MSG_PUB.Add;

3434: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'checking Interest receivables count');
3435: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Interest receivables count = ' || l_int_receivables_bill.count);
3436: if l_int_receivables_bill.count <> 1 then
3437: FND_MESSAGE.Set_Name('LNS', 'LNS_ACC_MULT_INT_RECEIVABLE');
3438: FND_MSG_PUB.Add;
3439: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
3440: RAISE FND_API.G_EXC_ERROR;
3441: end if;
3442:

Line 3439: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));

3435: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Interest receivables count = ' || l_int_receivables_bill.count);
3436: if l_int_receivables_bill.count <> 1 then
3437: FND_MESSAGE.Set_Name('LNS', 'LNS_ACC_MULT_INT_RECEIVABLE');
3438: FND_MSG_PUB.Add;
3439: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
3440: RAISE FND_API.G_EXC_ERROR;
3441: end if;
3442:
3443: -- I. There may be multiple Interest Income accounts

Line 3448: FND_MSG_PUB.Add;

3444: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'checking Interest Income count');
3445: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Interest Income count = ' || l_int_income_bill.count);
3446: if l_int_income_bill.count < 1 then
3447: FND_MESSAGE.Set_Name('LNS', 'LNS_ACC_NO_INTEREST_INCOME');
3448: FND_MSG_PUB.Add;
3449: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
3450: RAISE FND_API.G_EXC_ERROR;
3451: end if;
3452:

Line 3449: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));

3445: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Interest Income count = ' || l_int_income_bill.count);
3446: if l_int_income_bill.count < 1 then
3447: FND_MESSAGE.Set_Name('LNS', 'LNS_ACC_NO_INTEREST_INCOME');
3448: FND_MSG_PUB.Add;
3449: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
3450: RAISE FND_API.G_EXC_ERROR;
3451: end if;
3452:
3453: -- J. The distribution percentages for Interest Income must add to 100%

Line 3462: FND_MSG_PUB.Add;

3458: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'checking Interest Income percentage');
3459: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Interest Income percentage = ' || l_dist_percent_int_income);
3460: if l_dist_percent_int_income <> 100 then
3461: FND_MESSAGE.Set_Name('LNS', 'LNS_ACC_INT_INCOME_PER_INVALID');
3462: FND_MSG_PUB.Add;
3463: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
3464: RAISE FND_API.G_EXC_ERROR;
3465: end if;
3466:

Line 3463: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));

3459: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Interest Income percentage = ' || l_dist_percent_int_income);
3460: if l_dist_percent_int_income <> 100 then
3461: FND_MESSAGE.Set_Name('LNS', 'LNS_ACC_INT_INCOME_PER_INVALID');
3462: FND_MSG_PUB.Add;
3463: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
3464: RAISE FND_API.G_EXC_ERROR;
3465: end if;
3466:
3467: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count

Line 3467: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count

3463: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
3464: RAISE FND_API.G_EXC_ERROR;
3465: end if;
3466:
3467: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count
3468: ,p_data => x_msg_data);
3469:
3470: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, l_api_name || ' - END');
3471:

Line 3475: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count

3471:
3472: Exception
3473: WHEN FND_API.G_EXC_ERROR THEN
3474: x_return_status := FND_API.G_RET_STS_ERROR;
3475: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count
3476: ,p_data => x_msg_data);
3477: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
3478:
3479: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN

Line 3481: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count

3477: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
3478:
3479: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
3480: x_return_status := FND_API.G_RET_STS_ERROR;
3481: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count
3482: ,p_data => x_msg_data);
3483: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
3484:
3485: WHEN OTHERS THEN

Line 3487: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count

3483: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
3484:
3485: WHEN OTHERS THEN
3486: x_return_status := FND_API.G_RET_STS_ERROR;
3487: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count
3488: ,p_data => x_msg_data);
3489: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
3490:
3491: end validateAccounting;

Line 3630: FND_MSG_PUB.initialize;

3626: SAVEPOINT validateLoanLines;
3627:
3628: -- Initialize message list IF p_init_msg_list is set to TRUE.
3629: IF FND_API.to_Boolean(p_init_msg_list) THEN
3630: FND_MSG_PUB.initialize;
3631: END IF;
3632:
3633: -- Initialize API return status to SUCCESS
3634: x_return_status := FND_API.G_RET_STS_SUCCESS;

Line 3722: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);

3718: -- ---------------------------------------------------------------------
3719: -- End of API body
3720: -- ---------------------------------------------------------------------
3721:
3722: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
3723:
3724: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, l_api_name || ' - END');
3725:
3726: EXCEPTION

Line 3732: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);

3728: ROLLBACK TO validateLoanLines;
3729: x_return_status := FND_API.G_RET_STS_ERROR;
3730: x_msg_count := l_msg_count;
3731: x_msg_data := l_msg_data;
3732: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
3733: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
3734:
3735: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
3736: ROLLBACK TO validateLoanLines;

Line 3740: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);

3736: ROLLBACK TO validateLoanLines;
3737: x_return_status := FND_API.G_RET_STS_ERROR;
3738: x_msg_count := l_msg_count;
3739: x_msg_data := l_msg_data;
3740: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
3741: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
3742:
3743: WHEN OTHERS THEN
3744: ROLLBACK TO validateLoanLines;

Line 3748: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);

3744: ROLLBACK TO validateLoanLines;
3745: x_return_status := FND_API.G_RET_STS_ERROR;
3746: x_msg_count := l_msg_count;
3747: x_msg_data := l_msg_data;
3748: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
3749: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
3750:
3751: end validateLoanLines;
3752:

Line 3841: FND_MSG_PUB.initialize;

3837:
3838:
3839: -- Initialize message list IF p_init_msg_list is set to TRUE.
3840: IF FND_API.to_Boolean( p_init_msg_list ) THEN
3841: FND_MSG_PUB.initialize;
3842: END IF;
3843:
3844: -- Initialize API return status to SUCCESS
3845: x_return_status := FND_API.G_RET_STS_SUCCESS;

Line 4010: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);

4006: COMMIT;
4007: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, l_api_name || 'Commited');
4008: END IF;
4009:
4010: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
4011: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, l_api_name || ' - END');
4012:
4013: EXCEPTION
4014:

Line 4019: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);

4015: WHEN FND_API.G_EXC_ERROR THEN
4016: ROLLBACK TO create_DisbursementDistribs;
4017: x_return_status := FND_API.G_RET_STS_ERROR;
4018: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
4019: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
4020:
4021: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
4022: ROLLBACK TO create_DisbursementDistribs;
4023: x_return_status := FND_API.G_RET_STS_ERROR;

Line 4025: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);

4021: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
4022: ROLLBACK TO create_DisbursementDistribs;
4023: x_return_status := FND_API.G_RET_STS_ERROR;
4024: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
4025: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
4026:
4027: WHEN OTHERS THEN
4028: ROLLBACK TO create_DisbursementDistribs;
4029: x_return_status := FND_API.G_RET_STS_ERROR;

Line 4031: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);

4027: WHEN OTHERS THEN
4028: ROLLBACK TO create_DisbursementDistribs;
4029: x_return_status := FND_API.G_RET_STS_ERROR;
4030: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
4031: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
4032:
4033: end create_DisbursementDistribs;
4034:
4035:

Line 4329: FND_MSG_PUB.initialize;

4325: logMessage(FND_LOG.level_statement, G_PKG_NAME, 'p_loan_class_code = ' || p_loan_class_code);
4326:
4327: -- Initialize message list IF p_init_msg_list is set to TRUE.
4328: IF FND_API.to_Boolean( p_init_msg_list ) THEN
4329: FND_MSG_PUB.initialize;
4330: END IF;
4331:
4332: -- Initialize API return status to SUCCESS
4333: x_return_status := FND_API.G_RET_STS_SUCCESS;

Line 4392: FND_MSG_PUB.ADD;

4388:
4389: logMessage(FND_LOG.level_statement, G_PKG_NAME, 'l_return_status = ' || l_return_status);
4390: if l_return_status <> FND_API.G_RET_STS_SUCCESS then
4391: FND_MESSAGE.SET_NAME('LNS', 'LNS_DEFAULT_DIST_NOT_FOUND');
4392: FND_MSG_PUB.ADD;
4393: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
4394: RAISE FND_API.G_EXC_ERROR;
4395: end if;
4396:

Line 4393: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));

4389: logMessage(FND_LOG.level_statement, G_PKG_NAME, 'l_return_status = ' || l_return_status);
4390: if l_return_status <> FND_API.G_RET_STS_SUCCESS then
4391: FND_MESSAGE.SET_NAME('LNS', 'LNS_DEFAULT_DIST_NOT_FOUND');
4392: FND_MSG_PUB.ADD;
4393: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
4394: RAISE FND_API.G_EXC_ERROR;
4395: end if;
4396:
4397: /* delete any rows for this loan before inheritance do not delete FEE_RECEIVABLE or FEE_INCOME rows*/

Line 4425: FND_MSG_PUB.ADD;

4421: close c_subsidy_rate;
4422: exception
4423: when no_data_found then
4424: FND_MESSAGE.SET_NAME('LNS', 'LNS_NO_SUBSIDY_RATE');
4425: FND_MSG_PUB.ADD;
4426: RAISE FND_API.G_EXC_ERROR;
4427: end;
4428:
4429: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, l_api_name || ' l_subsidy_rate ' || l_subsidy_rate );

Line 4447: FND_MSG_PUB.ADD;

4443: ,X_MSG_DATA => l_msg_data);
4444: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, l_api_name || ' update loan status = ' || l_return_status);
4445: if l_return_status <> 'S' then
4446: FND_MESSAGE.SET_NAME('LNS', 'LNS_UPD_LOAN_FAIL');
4447: FND_MSG_PUB.ADD;
4448: RAISE FND_API.G_EXC_ERROR;
4449: end if;
4450: */
4451: logMessage(FND_LOG.level_statement, G_PKG_NAME, 'DIRECT LOAN INHERITANCE');

Line 4532: FND_MSG_PUB.ADD;

4528:
4529: if l_return_status <> 'S' then
4530: FND_MESSAGE.SET_NAME('LNS', 'LNS_CHK_UPG_FAIL');
4531: FND_MESSAGE.SET_TOKEN('DOC_NUM', l_trx_number);
4532: FND_MSG_PUB.ADD;
4533: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
4534: RAISE FND_API.G_EXC_ERROR;
4535: else
4536: if l_upgrade_status <> 'Y' then

Line 4533: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));

4529: if l_return_status <> 'S' then
4530: FND_MESSAGE.SET_NAME('LNS', 'LNS_CHK_UPG_FAIL');
4531: FND_MESSAGE.SET_TOKEN('DOC_NUM', l_trx_number);
4532: FND_MSG_PUB.ADD;
4533: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
4534: RAISE FND_API.G_EXC_ERROR;
4535: else
4536: if l_upgrade_status <> 'Y' then
4537: FND_MESSAGE.SET_NAME('LNS', 'LNS_INVALID_TRX');

Line 4539: FND_MSG_PUB.ADD;

4535: else
4536: if l_upgrade_status <> 'Y' then
4537: FND_MESSAGE.SET_NAME('LNS', 'LNS_INVALID_TRX');
4538: FND_MESSAGE.SET_TOKEN('DOC_NUM', l_trx_number);
4539: FND_MSG_PUB.ADD;
4540: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
4541: RAISE FND_API.G_EXC_ERROR;
4542: end if;
4543: end if;

Line 4540: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));

4536: if l_upgrade_status <> 'Y' then
4537: FND_MESSAGE.SET_NAME('LNS', 'LNS_INVALID_TRX');
4538: FND_MESSAGE.SET_TOKEN('DOC_NUM', l_trx_number);
4539: FND_MSG_PUB.ADD;
4540: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
4541: RAISE FND_API.G_EXC_ERROR;
4542: end if;
4543: end if;
4544:

Line 4602: FND_MSG_PUB.Add;

4598: l_error_counter := l_error_counter + 1;
4599:
4600: if l_error_counter = 1 then
4601: FND_MESSAGE.SET_NAME('LNS', 'LNS_ONLINE_ACCOUNTING_FAILED');
4602: FND_MSG_PUB.Add;
4603: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
4604: end if;
4605:
4606: FND_MESSAGE.SET_NAME('LNS', 'LNS_ACC_DOC_FAIL');

Line 4603: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));

4599:
4600: if l_error_counter = 1 then
4601: FND_MESSAGE.SET_NAME('LNS', 'LNS_ONLINE_ACCOUNTING_FAILED');
4602: FND_MSG_PUB.Add;
4603: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
4604: end if;
4605:
4606: FND_MESSAGE.SET_NAME('LNS', 'LNS_ACC_DOC_FAIL');
4607: FND_MESSAGE.SET_TOKEN('DOC_NUM', l_invoice_number);

Line 4610: FND_MSG_PUB.Add;

4606: FND_MESSAGE.SET_NAME('LNS', 'LNS_ACC_DOC_FAIL');
4607: FND_MESSAGE.SET_TOKEN('DOC_NUM', l_invoice_number);
4608: FND_MESSAGE.SET_TOKEN('DOC_TYPE', l_entity_code);
4609: FND_MESSAGE.SET_TOKEN('ACC_ERR', l_error_message);
4610: FND_MSG_PUB.Add;
4611: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
4612:
4613: END LOOP;
4614:

Line 4611: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));

4607: FND_MESSAGE.SET_TOKEN('DOC_NUM', l_invoice_number);
4608: FND_MESSAGE.SET_TOKEN('DOC_TYPE', l_entity_code);
4609: FND_MESSAGE.SET_TOKEN('ACC_ERR', l_error_message);
4610: FND_MSG_PUB.Add;
4611: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
4612:
4613: END LOOP;
4614:
4615: close c_acc_errors;

Line 4644: FND_MSG_PUB.ADD;

4640: ,flex_qual_name => 'GL_ACCOUNT'
4641: ,segment_number => l_nat_acct_seg_number))
4642: THEN
4643: FND_MESSAGE.SET_NAME('LNS', 'LNS_NO_NATURAL_ACCOUNT_SEGMENT');
4644: FND_MSG_PUB.ADD;
4645: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
4646: RAISE FND_API.G_EXC_ERROR;
4647: END IF;
4648: logMessage(FND_LOG.level_statement, G_PKG_NAME, 'Natural acct segment = ' || l_nat_acct_seg_number);

Line 4645: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));

4641: ,segment_number => l_nat_acct_seg_number))
4642: THEN
4643: FND_MESSAGE.SET_NAME('LNS', 'LNS_NO_NATURAL_ACCOUNT_SEGMENT');
4644: FND_MSG_PUB.ADD;
4645: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
4646: RAISE FND_API.G_EXC_ERROR;
4647: END IF;
4648: logMessage(FND_LOG.level_statement, G_PKG_NAME, 'Natural acct segment = ' || l_nat_acct_seg_number);
4649: END IF;

Line 4690: FND_MSG_PUB.ADD;

4686: exception
4687: when others then
4688: --logMessage(FND_LOG.LEVEL_UNEX, G_PKG_NAME, 'Failed to inherit receivables distributions');
4689: FND_MESSAGE.SET_NAME('LNS', 'LNS_INHERIT_DIST_NOT_FOUND');
4690: FND_MSG_PUB.ADD;
4691: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
4692: RAISE FND_API.G_EXC_ERROR;
4693: end;
4694:

Line 4691: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));

4687: when others then
4688: --logMessage(FND_LOG.LEVEL_UNEX, G_PKG_NAME, 'Failed to inherit receivables distributions');
4689: FND_MESSAGE.SET_NAME('LNS', 'LNS_INHERIT_DIST_NOT_FOUND');
4690: FND_MSG_PUB.ADD;
4691: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
4692: RAISE FND_API.G_EXC_ERROR;
4693: end;
4694:
4695: --logMessage(FND_LOG.level_statement, G_PKG_NAME, 'After loan clearing lines calculated. total amount due = ' || l_total_amount_due);

Line 4711: FND_MSG_PUB.ADD;

4707: logMessage(FND_LOG.level_statement, G_PKG_NAME, 'Default Adjustment CCID is '||l_code_combination_id);
4708:
4709: IF l_code_combination_id IS NULL THEN
4710: FND_MESSAGE.SET_NAME('LNS', 'LNS_INHERIT_DIST_NOT_FOUND');
4711: FND_MSG_PUB.ADD;
4712: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
4713: RAISE FND_API.G_EXC_ERROR;
4714: END IF;
4715:

Line 4712: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));

4708:
4709: IF l_code_combination_id IS NULL THEN
4710: FND_MESSAGE.SET_NAME('LNS', 'LNS_INHERIT_DIST_NOT_FOUND');
4711: FND_MSG_PUB.ADD;
4712: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
4713: RAISE FND_API.G_EXC_ERROR;
4714: END IF;
4715:
4716: l_distributionsCLEAR_ORIG(i).line_type := 'CLEAR';

Line 4828: FND_MSG_PUB.ADD;

4824: exception
4825: when others then
4826: -- logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, 'failed to inherit receivables distributions');
4827: FND_MESSAGE.SET_NAME('LNS', 'LNS_INHERIT_DIST_NOT_FOUND');
4828: FND_MSG_PUB.ADD;
4829: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
4830: RAISE FND_API.G_EXC_ERROR;
4831: end;
4832:

Line 4829: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));

4825: when others then
4826: -- logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, 'failed to inherit receivables distributions');
4827: FND_MESSAGE.SET_NAME('LNS', 'LNS_INHERIT_DIST_NOT_FOUND');
4828: FND_MSG_PUB.ADD;
4829: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
4830: RAISE FND_API.G_EXC_ERROR;
4831: end;
4832:
4833: else

Line 5002: FND_MSG_PUB.ADD;

4998:
4999: logMessage(FND_LOG.level_statement, G_PKG_NAME, 'l_return_status = ' || l_return_status);
5000: if l_return_status <> 'S' then
5001: FND_MESSAGE.SET_NAME('LNS', 'LNS_DEFAULT_DIST_NOT_FOUND');
5002: FND_MSG_PUB.ADD;
5003: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
5004: RAISE FND_API.G_EXC_ERROR;
5005: end if;
5006:

Line 5003: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));

4999: logMessage(FND_LOG.level_statement, G_PKG_NAME, 'l_return_status = ' || l_return_status);
5000: if l_return_status <> 'S' then
5001: FND_MESSAGE.SET_NAME('LNS', 'LNS_DEFAULT_DIST_NOT_FOUND');
5002: FND_MSG_PUB.ADD;
5003: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
5004: RAISE FND_API.G_EXC_ERROR;
5005: end if;
5006:
5007: IF FND_API.to_Boolean(p_commit) THEN

Line 5011: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);

5007: IF FND_API.to_Boolean(p_commit) THEN
5008: COMMIT WORK;
5009: END IF;
5010:
5011: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
5012: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, l_api_name || ' - END');
5013:
5014: EXCEPTION
5015:

Line 5019: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);

5015:
5016: WHEN FND_API.G_EXC_ERROR THEN
5017: ROLLBACK TO defaultDistributions;
5018: x_return_status := FND_API.G_RET_STS_ERROR;
5019: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
5020: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
5021:
5022: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
5023: ROLLBACK TO defaultDistributions;

Line 5025: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);

5021:
5022: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
5023: ROLLBACK TO defaultDistributions;
5024: x_return_status := FND_API.G_RET_STS_ERROR;
5025: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
5026: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
5027:
5028: WHEN OTHERS THEN
5029: ROLLBACK TO defaultDistributions;

Line 5031: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);

5027:
5028: WHEN OTHERS THEN
5029: ROLLBACK TO defaultDistributions;
5030: x_return_status := FND_API.G_RET_STS_ERROR;
5031: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
5032: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
5033:
5034: end defaultDistributions;
5035:

Line 5164: FND_MSG_PUB.initialize;

5160: -- Initialize API return status to SUCCESS
5161: x_return_status := FND_API.G_RET_STS_SUCCESS;
5162: -- Initialize message list IF p_init_msg_list is set to TRUE.
5163: IF FND_API.to_Boolean( p_init_msg_list ) THEN
5164: FND_MSG_PUB.initialize;
5165: END IF;
5166:
5167: open c_loan_info(p_loan_id);
5168: fetch c_loan_info into l_legal_entity_id, l_loan_class;

Line 5239: --FND_MSG_PUB.Add;

5235:
5236: if l_retcode = 0 then
5237:
5238: --FND_MESSAGE.SET_NAME('XLA', 'XLA_ONLINE_ACCT_SUCCESS');
5239: --FND_MSG_PUB.Add;
5240: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'online accounting SUCCESS! ');
5241:
5242: elsif l_retcode = 2 then
5243:

Line 5245: FND_MSG_PUB.Add;

5241:
5242: elsif l_retcode = 2 then
5243:
5244: FND_MESSAGE.SET_NAME('XLA', 'XLA_ONLINE_ACCTG_ERROR');
5245: FND_MSG_PUB.Add;
5246: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
5247: RAISE FND_API.G_EXC_ERROR;
5248:
5249: elsif l_retcode = 1 then

Line 5246: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));

5242: elsif l_retcode = 2 then
5243:
5244: FND_MESSAGE.SET_NAME('XLA', 'XLA_ONLINE_ACCTG_ERROR');
5245: FND_MSG_PUB.Add;
5246: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
5247: RAISE FND_API.G_EXC_ERROR;
5248:
5249: elsif l_retcode = 1 then
5250:

Line 5268: FND_MSG_PUB.Add;

5264: l_error_counter := l_error_counter + 1;
5265:
5266: if l_error_counter = 1 then
5267: FND_MESSAGE.SET_NAME('XLA', 'XLA_ONLINE_ACCT_WARNING');
5268: FND_MSG_PUB.Add;
5269: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
5270: end if;
5271:
5272: FND_MESSAGE.SET_NAME('LNS', 'LNS_ACC_DOC_FAIL');

Line 5269: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));

5265:
5266: if l_error_counter = 1 then
5267: FND_MESSAGE.SET_NAME('XLA', 'XLA_ONLINE_ACCT_WARNING');
5268: FND_MSG_PUB.Add;
5269: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
5270: end if;
5271:
5272: FND_MESSAGE.SET_NAME('LNS', 'LNS_ACC_DOC_FAIL');
5273: FND_MESSAGE.SET_TOKEN('DOC_NUM', l_invoice_number);

Line 5276: FND_MSG_PUB.Add;

5272: FND_MESSAGE.SET_NAME('LNS', 'LNS_ACC_DOC_FAIL');
5273: FND_MESSAGE.SET_TOKEN('DOC_NUM', l_invoice_number);
5274: FND_MESSAGE.SET_TOKEN('DOC_TYPE', l_entity_code);
5275: FND_MESSAGE.SET_TOKEN('ACC_ERR', l_error_message);
5276: FND_MSG_PUB.Add;
5277: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
5278:
5279: END LOOP;
5280:

Line 5277: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));

5273: FND_MESSAGE.SET_TOKEN('DOC_NUM', l_invoice_number);
5274: FND_MESSAGE.SET_TOKEN('DOC_TYPE', l_entity_code);
5275: FND_MESSAGE.SET_TOKEN('ACC_ERR', l_error_message);
5276: FND_MSG_PUB.Add;
5277: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
5278:
5279: END LOOP;
5280:
5281: close c_acc_errors;

Line 5286: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);

5282:
5283: RAISE FND_API.G_EXC_ERROR;
5284: end if;
5285:
5286: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
5287: commit;
5288: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, l_api_name || ' - END');
5289:
5290: EXCEPTION

Line 5296: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);

5292: WHEN FND_API.G_EXC_ERROR THEN
5293: ROLLBACK TO onlineAccounting;
5294: x_return_status := FND_API.G_RET_STS_ERROR;
5295: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
5296: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
5297:
5298: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
5299: ROLLBACK TO onlineAccounting;
5300: x_return_status := FND_API.G_RET_STS_ERROR;

Line 5302: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);

5298: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
5299: ROLLBACK TO onlineAccounting;
5300: x_return_status := FND_API.G_RET_STS_ERROR;
5301: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
5302: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
5303:
5304: WHEN OTHERS THEN
5305: ROLLBACK TO onlineAccounting;
5306: x_return_status := FND_API.G_RET_STS_ERROR;

Line 5308: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);

5304: WHEN OTHERS THEN
5305: ROLLBACK TO onlineAccounting;
5306: x_return_status := FND_API.G_RET_STS_ERROR;
5307: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
5308: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
5309:
5310: end onlineAccounting;
5311:
5312:

Line 5390: FND_MSG_PUB.Add;

5386: if P_LOAN_ID is null then
5387:
5388: -- LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'ERROR: Loan must be set.');
5389: FND_MESSAGE.SET_NAME('LNS', 'LNS_NO_LOAN');
5390: FND_MSG_PUB.Add;
5391: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
5392: RAISE FND_API.G_EXC_ERROR;
5393:
5394: end if;

Line 5391: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));

5387:
5388: -- LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'ERROR: Loan must be set.');
5389: FND_MESSAGE.SET_NAME('LNS', 'LNS_NO_LOAN');
5390: FND_MSG_PUB.Add;
5391: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
5392: RAISE FND_API.G_EXC_ERROR;
5393:
5394: end if;
5395:

Line 5429: FND_MSG_PUB.ADD;

5425: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'l_return_status = ' || l_return_status);
5426:
5427: IF l_return_status <> FND_API.G_RET_STS_SUCCESS THEN
5428: FND_MESSAGE.SET_NAME('LNS', 'LNS_ACCOUNTING_EVENT_ERROR');
5429: FND_MSG_PUB.ADD;
5430: --l_last_api_called := 'LNS_XLA_EVENTS.create_event';
5431: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
5432: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
5433: END IF;

Line 5431: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));

5427: IF l_return_status <> FND_API.G_RET_STS_SUCCESS THEN
5428: FND_MESSAGE.SET_NAME('LNS', 'LNS_ACCOUNTING_EVENT_ERROR');
5429: FND_MSG_PUB.ADD;
5430: --l_last_api_called := 'LNS_XLA_EVENTS.create_event';
5431: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
5432: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
5433: END IF;
5434:
5435:

Line 5533: FND_MSG_PUB.Add;

5529:
5530: if l_request_id = 0 then
5531: l_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
5532: FND_MESSAGE.SET_NAME('LNS', 'LNS_BILLING_REQUEST_FAILED');
5533: FND_MSG_PUB.Add;
5534: l_last_api_called := 'FND_REQUEST.SUBMIT_REQUEST for 0th installment billing';
5535: RAISE FND_API.G_EXC_ERROR;
5536: else
5537: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Successfully submited Billing Concurrent Program to bill 0-th installment. Request id = ' || l_request_id);

Line 5556: fnd_msg_pub.count_and_get(p_count => l_msg_count, p_data => ERRBUF);

5552: l_return := FND_CONCURRENT.SET_COMPLETION_STATUS(
5553: status => 'ERROR',
5554: message => 'Generate Distributions process has failed. Please review log file.');
5555: RETCODE := FND_API.G_RET_STS_ERROR;
5556: fnd_msg_pub.count_and_get(p_count => l_msg_count, p_data => ERRBUF);
5557: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, ' ');
5558: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, '-------------------');
5559: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Generate Distributions process has failed!');
5560:

Line 5601: FND_MSG_PUB.initialize;

5597: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, l_api_name || ' - BEGIN');
5598:
5599: -- Initialize message list IF p_init_msg_list is set to TRUE.
5600: IF FND_API.to_Boolean( p_init_msg_list ) THEN
5601: FND_MSG_PUB.initialize;
5602: END IF;
5603:
5604: -- Initialize API return status to SUCCESS
5605: x_return_status := FND_API.G_RET_STS_SUCCESS;

Line 5626: FND_MSG_PUB.ADD;

5622:
5623: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, l_api_name || 'Accounting status is ' || l_return_status);
5624: if l_return_status <> 'S' then
5625: FND_MESSAGE.SET_NAME('LNS', 'LNS_DEFAULT_DIST_NOT_FOUND');
5626: FND_MSG_PUB.ADD;
5627: RAISE FND_API.G_EXC_ERROR;
5628: end if;
5629:
5630: /* For Import Loans, there is no need to create SLA events and accounting b'coz the imported loan accounting date

Line 5657: FND_MSG_PUB.ADD;

5653: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'l_return_status = ' || l_return_status);
5654:
5655: IF l_return_status <> FND_API.G_RET_STS_SUCCESS THEN
5656: FND_MESSAGE.SET_NAME('LNS', 'LNS_ACCOUNTING_EVENT_ERROR');
5657: FND_MSG_PUB.ADD;
5658: --l_last_api_called := 'LNS_XLA_EVENTS.create_event';
5659: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
5660: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
5661: END IF;

Line 5659: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));

5655: IF l_return_status <> FND_API.G_RET_STS_SUCCESS THEN
5656: FND_MESSAGE.SET_NAME('LNS', 'LNS_ACCOUNTING_EVENT_ERROR');
5657: FND_MSG_PUB.ADD;
5658: --l_last_api_called := 'LNS_XLA_EVENTS.create_event';
5659: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
5660: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
5661: END IF;
5662:
5663: if l_event_id is not null then

Line 5682: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);

5678: THEN
5679: COMMIT WORK;
5680: END IF;
5681:
5682: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
5683:
5684: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, l_api_name || ' - END');
5685:
5686: EXCEPTION

Line 5768: FND_MSG_PUB.initialize;

5764: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'p_loan_id = ' || p_loan_id);
5765:
5766: -- Initialize message list IF p_init_msg_list is set to TRUE.
5767: IF FND_API.to_Boolean( p_init_msg_list ) THEN
5768: FND_MSG_PUB.initialize;
5769: END IF;
5770:
5771: -- Initialize API return status to SUCCESS
5772: x_return_status := FND_API.G_RET_STS_SUCCESS;

Line 5792: FND_MSG_PUB.ADD;

5788: if l_return_status <> FND_API.G_RET_STS_SUCCESS then
5789: FND_MESSAGE.SET_NAME('LNS', 'LNS_INVALID_VALUE');
5790: FND_MESSAGE.SET_TOKEN('PARAMETER', 'LOAN_ID');
5791: FND_MESSAGE.SET_TOKEN('VALUE', p_loan_id);
5792: FND_MSG_PUB.ADD;
5793: RAISE FND_API.G_EXC_ERROR;
5794: end if;
5795:
5796: OPEN c_loan_adj(p_loan_id);

Line 5810: FND_MSG_PUB.ADD;

5806: IF (l_loan_amount_adj_id IS NULL) THEN
5807: FND_MESSAGE.SET_NAME('LNS', 'LNS_INVALID_VALUE');
5808: FND_MESSAGE.SET_TOKEN('PARAMETER', 'LOAN_AMOUNT_ADJ_ID');
5809: FND_MESSAGE.SET_TOKEN('VALUE', l_loan_amount_adj_id);
5810: FND_MSG_PUB.ADD;
5811: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
5812: RAISE FND_API.G_EXC_ERROR;
5813: END IF;
5814:

Line 5811: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));

5807: FND_MESSAGE.SET_NAME('LNS', 'LNS_INVALID_VALUE');
5808: FND_MESSAGE.SET_TOKEN('PARAMETER', 'LOAN_AMOUNT_ADJ_ID');
5809: FND_MESSAGE.SET_TOKEN('VALUE', l_loan_amount_adj_id);
5810: FND_MSG_PUB.ADD;
5811: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
5812: RAISE FND_API.G_EXC_ERROR;
5813: END IF;
5814:
5815:

Line 5834: FND_MSG_PUB.ADD;

5830: if l_return_status <> FND_API.G_RET_STS_SUCCESS then
5831: FND_MESSAGE.SET_NAME('LNS', 'LNS_INVALID_VALUE');
5832: FND_MESSAGE.SET_TOKEN('PARAMETER', 'LOAN_AMOUNT_ADJ_ID');
5833: FND_MESSAGE.SET_TOKEN('VALUE', p_loan_amount_adj_id);
5834: FND_MSG_PUB.ADD;
5835: RAISE FND_API.G_EXC_ERROR;
5836: end if;
5837:
5838:

Line 5859: FND_MSG_PUB.ADD;

5855:
5856: FND_MESSAGE.SET_NAME('LNS', 'LNS_INVALID_VALUE');
5857: FND_MESSAGE.SET_TOKEN('PARAMETER', 'LOAN_AMOUNT_ADJ_ID');
5858: FND_MESSAGE.SET_TOKEN('VALUE', l_loan_amount_adj_id);
5859: FND_MSG_PUB.ADD;
5860: RAISE FND_API.G_EXC_ERROR;
5861:
5862: ELSE
5863: /* delete any rows for this loan before inheritance do not delete FEE_RECEIVABLE or FEE_INCOME rows*/

Line 5902: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);

5898: WHEN FND_API.G_EXC_ERROR THEN
5899: ROLLBACK TO adjustment_distribs_pvt;
5900: x_return_status := FND_API.G_RET_STS_ERROR;
5901: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
5902: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
5903:
5904: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
5905: ROLLBACK TO adjustment_distribs_pvt;
5906: x_return_status := FND_API.G_RET_STS_ERROR;

Line 5908: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);

5904: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
5905: ROLLBACK TO adjustment_distribs_pvt;
5906: x_return_status := FND_API.G_RET_STS_ERROR;
5907: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
5908: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
5909:
5910: WHEN OTHERS THEN
5911: ROLLBACK TO adjustment_distribs_pvt;
5912: x_return_status := FND_API.G_RET_STS_ERROR;

Line 5914: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);

5910: WHEN OTHERS THEN
5911: ROLLBACK TO adjustment_distribs_pvt;
5912: x_return_status := FND_API.G_RET_STS_ERROR;
5913: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
5914: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
5915: END DEFAULT_ADJUSTMENT_DISTRIBS;
5916:
5917: /*=========================================================================
5918: || PROCEDURE LOAN_ADJUSTMENT_BUDGET_CONTROL

Line 6043: FND_MSG_PUB.initialize;

6039: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'p_budgetary_control_mode = ' || p_budgetary_control_mode);
6040:
6041: -- Initialize message list IF p_init_msg_list is set to TRUE.
6042: IF FND_API.to_Boolean( p_init_msg_list ) THEN
6043: FND_MSG_PUB.initialize;
6044: END IF;
6045:
6046: -- Initialize API return status to SUCCESS
6047: x_return_status := FND_API.G_RET_STS_SUCCESS;

Line 6067: FND_MSG_PUB.ADD;

6063: if l_return_status <> FND_API.G_RET_STS_SUCCESS then
6064: FND_MESSAGE.SET_NAME('LNS', 'LNS_INVALID_VALUE');
6065: FND_MESSAGE.SET_TOKEN('PARAMETER', 'LOAN_ID');
6066: FND_MESSAGE.SET_TOKEN('VALUE', p_loan_id);
6067: FND_MSG_PUB.ADD;
6068: RAISE FND_API.G_EXC_ERROR;
6069: end if;
6070:
6071: OPEN c_loan_adj(p_loan_id);

Line 6082: FND_MSG_PUB.ADD;

6078: IF (l_loan_amount_adj_id IS NULL) THEN
6079: FND_MESSAGE.SET_NAME('LNS', 'LNS_INVALID_VALUE');
6080: FND_MESSAGE.SET_TOKEN('PARAMETER', 'LOAN_AMOUNT_ADJ_ID');
6081: FND_MESSAGE.SET_TOKEN('VALUE', l_loan_amount_adj_id);
6082: FND_MSG_PUB.ADD;
6083: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
6084: RAISE FND_API.G_EXC_ERROR;
6085: END IF;
6086:

Line 6083: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));

6079: FND_MESSAGE.SET_NAME('LNS', 'LNS_INVALID_VALUE');
6080: FND_MESSAGE.SET_TOKEN('PARAMETER', 'LOAN_AMOUNT_ADJ_ID');
6081: FND_MESSAGE.SET_TOKEN('VALUE', l_loan_amount_adj_id);
6082: FND_MSG_PUB.ADD;
6083: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
6084: RAISE FND_API.G_EXC_ERROR;
6085: END IF;
6086:
6087:

Line 6106: FND_MSG_PUB.ADD;

6102: if l_return_status <> FND_API.G_RET_STS_SUCCESS then
6103: FND_MESSAGE.SET_NAME('LNS', 'LNS_INVALID_VALUE');
6104: FND_MESSAGE.SET_TOKEN('PARAMETER', 'LOAN_AMOUNT_ADJ_ID');
6105: FND_MESSAGE.SET_TOKEN('VALUE', p_loan_amount_adj_id);
6106: FND_MSG_PUB.ADD;
6107: RAISE FND_API.G_EXC_ERROR;
6108: end if;
6109:
6110:

Line 6126: FND_MSG_PUB.ADD;

6122: IF l_adj_status <> 'PENDING' THEN
6123: FND_MESSAGE.SET_NAME('LNS', 'LNS_CHK_PENDING_ADJ');
6124: FND_MESSAGE.SET_TOKEN('PARAMETER', 'LOAN_ID');
6125: FND_MESSAGE.SET_TOKEN('VALUE', l_loan_id);
6126: FND_MSG_PUB.ADD;
6127: RAISE FND_API.G_EXC_ERROR;
6128: END IF;
6129:
6130: l_loan_amount_adj_id := p_loan_amount_adj_id;

Line 6178: FND_MSG_PUB.ADD;

6174: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'x_event_id ' || l_event_id);
6175:
6176: IF x_return_status <> FND_API.G_RET_STS_SUCCESS THEN
6177: FND_MESSAGE.SET_NAME('LNS', 'LNS_ACCOUNTING_EVENT_ERROR');
6178: FND_MSG_PUB.ADD;
6179: logMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
6180: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
6181: END IF;
6182:

Line 6179: logMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));

6175:
6176: IF x_return_status <> FND_API.G_RET_STS_SUCCESS THEN
6177: FND_MESSAGE.SET_NAME('LNS', 'LNS_ACCOUNTING_EVENT_ERROR');
6178: FND_MSG_PUB.ADD;
6179: logMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
6180: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
6181: END IF;
6182:
6183: -- stamp the eventID onto the lns_distributions table

Line 6235: FND_MSG_PUB.ADD;

6231:
6232: l_return_status := FND_API.G_RET_STS_ERROR;
6233: FND_MESSAGE.SET_NAME('LNS', 'LNS_API_OTHERS_EXCEP');
6234: FND_MESSAGE.SET_TOKEN('ERROR' ,'Call to PSA_BC_XLA_PUB.Budgetary_Control failed with Status Code = ' || l_status_code);
6235: FND_MSG_PUB.ADD;
6236: logMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
6237: RAISE FND_API.G_EXC_ERROR;
6238:
6239: else

Line 6236: logMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));

6232: l_return_status := FND_API.G_RET_STS_ERROR;
6233: FND_MESSAGE.SET_NAME('LNS', 'LNS_API_OTHERS_EXCEP');
6234: FND_MESSAGE.SET_TOKEN('ERROR' ,'Call to PSA_BC_XLA_PUB.Budgetary_Control failed with Status Code = ' || l_status_code);
6235: FND_MSG_PUB.ADD;
6236: logMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
6237: RAISE FND_API.G_EXC_ERROR;
6238:
6239: else
6240: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'l_budget_req_approval = ' || l_budget_req_approval);

Line 6250: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);

6246: x_return_status := l_return_status;
6247:
6248: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, ' BudgetReserve is not mandatory for LoanAdjustment Approval, so returning to invoked method');
6249:
6250: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
6251:
6252: return;
6253:
6254: end if;

Line 6260: FND_MSG_PUB.ADD;

6256: /*
6257: if l_status_code NOT IN ('SUCCESS','ADVISORY') then
6258: IF (l_status_code = 'PARTIAL') THEN
6259: FND_MESSAGE.SET_NAME('LNS', 'LNS_FUND_CHK_PARTIAL');
6260: FND_MSG_PUB.ADD;
6261: logMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
6262: RAISE FND_API.G_EXC_ERROR;
6263: ELSE
6264: FND_MESSAGE.SET_NAME('LNS', 'LNS_API_OTHERS_EXCEP');

Line 6261: logMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));

6257: if l_status_code NOT IN ('SUCCESS','ADVISORY') then
6258: IF (l_status_code = 'PARTIAL') THEN
6259: FND_MESSAGE.SET_NAME('LNS', 'LNS_FUND_CHK_PARTIAL');
6260: FND_MSG_PUB.ADD;
6261: logMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
6262: RAISE FND_API.G_EXC_ERROR;
6263: ELSE
6264: FND_MESSAGE.SET_NAME('LNS', 'LNS_API_OTHERS_EXCEP');
6265: FND_MESSAGE.SET_TOKEN('ERROR' ,'Call to PSA_BC_XLA_PUB.Budgetary_Control failed with Status Code = ' || l_status_code);

Line 6266: FND_MSG_PUB.ADD;

6262: RAISE FND_API.G_EXC_ERROR;
6263: ELSE
6264: FND_MESSAGE.SET_NAME('LNS', 'LNS_API_OTHERS_EXCEP');
6265: FND_MESSAGE.SET_TOKEN('ERROR' ,'Call to PSA_BC_XLA_PUB.Budgetary_Control failed with Status Code = ' || l_status_code);
6266: FND_MSG_PUB.ADD;
6267: logMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
6268: RAISE FND_API.G_EXC_ERROR;
6269: END IF;
6270: end if;

Line 6267: logMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));

6263: ELSE
6264: FND_MESSAGE.SET_NAME('LNS', 'LNS_API_OTHERS_EXCEP');
6265: FND_MESSAGE.SET_TOKEN('ERROR' ,'Call to PSA_BC_XLA_PUB.Budgetary_Control failed with Status Code = ' || l_status_code);
6266: FND_MSG_PUB.ADD;
6267: logMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
6268: RAISE FND_API.G_EXC_ERROR;
6269: END IF;
6270: end if;
6271: */

Line 6291: FND_MSG_PUB.ADD;

6287: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'update loan status = ' || l_return_status);
6288:
6289: if l_return_status <> 'S' then
6290: FND_MESSAGE.SET_NAME('LNS', 'LNS_UPD_LOAN_FAIL');
6291: FND_MSG_PUB.ADD;
6292: logMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
6293: RAISE FND_API.G_EXC_ERROR;
6294: end if;
6295: END IF;

Line 6292: logMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));

6288:
6289: if l_return_status <> 'S' then
6290: FND_MESSAGE.SET_NAME('LNS', 'LNS_UPD_LOAN_FAIL');
6291: FND_MSG_PUB.ADD;
6292: logMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
6293: RAISE FND_API.G_EXC_ERROR;
6294: end if;
6295: END IF;
6296:

Line 6320: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);

6316: WHEN FND_API.G_EXC_ERROR THEN
6317: ROLLBACK TO loan_adj_reverse_bc_pvt;
6318: x_return_status := FND_API.G_RET_STS_ERROR;
6319: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
6320: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
6321:
6322: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
6323: ROLLBACK TO loan_adj_reverse_bc_pvt;
6324: x_return_status := FND_API.G_RET_STS_ERROR;

Line 6326: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);

6322: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
6323: ROLLBACK TO loan_adj_reverse_bc_pvt;
6324: x_return_status := FND_API.G_RET_STS_ERROR;
6325: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
6326: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
6327:
6328: WHEN OTHERS THEN
6329: ROLLBACK TO loan_adj_reverse_bc_pvt;
6330: x_return_status := FND_API.G_RET_STS_ERROR;

Line 6332: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);

6328: WHEN OTHERS THEN
6329: ROLLBACK TO loan_adj_reverse_bc_pvt;
6330: x_return_status := FND_API.G_RET_STS_ERROR;
6331: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
6332: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
6333:
6334: END LOAN_ADJUSTMENT_BUDGET_CONTROL;
6335:
6336:

Line 6386: FND_MSG_PUB.initialize;

6382: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, l_api_name || ' - BEGIN');
6383:
6384: -- Initialize message list IF p_init_msg_list is set to TRUE.
6385: IF FND_API.to_Boolean( p_init_msg_list ) THEN
6386: FND_MSG_PUB.initialize;
6387: END IF;
6388:
6389: -- Initialize API return status to SUCCESS
6390: x_return_status := FND_API.G_RET_STS_SUCCESS;

Line 6430: FND_MSG_PUB.Add;

6426:
6427: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'l_dist_percent_rec_bill = ' || l_dist_percent_rec_bill);
6428: if l_dist_percent_rec_bill <> 100 then
6429: FND_MESSAGE.Set_Name('LNS', 'LNS_ACC_BILL_REC_PER_INVALID');
6430: FND_MSG_PUB.Add;
6431: RAISE FND_API.G_EXC_ERROR;
6432: end if;
6433:
6434: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count

Line 6434: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count

6430: FND_MSG_PUB.Add;
6431: RAISE FND_API.G_EXC_ERROR;
6432: end if;
6433:
6434: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count
6435: ,p_data => x_msg_data);
6436:
6437: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, l_api_name || ' - END');
6438:

Line 6442: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count

6438:
6439: Exception
6440: WHEN FND_API.G_EXC_ERROR THEN
6441: x_return_status := FND_API.G_RET_STS_ERROR;
6442: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count
6443: ,p_data => x_msg_data);
6444: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
6445:
6446: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN

Line 6448: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count

6444: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
6445:
6446: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
6447: x_return_status := FND_API.G_RET_STS_ERROR;
6448: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count
6449: ,p_data => x_msg_data);
6450: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
6451:
6452: WHEN OTHERS THEN

Line 6454: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count

6450: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
6451:
6452: WHEN OTHERS THEN
6453: x_return_status := FND_API.G_RET_STS_ERROR;
6454: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count
6455: ,p_data => x_msg_data);
6456: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
6457:
6458: end;

Line 6728: FND_MSG_PUB.initialize;

6724: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, l_api_name || ' - BEGIN');
6725:
6726: -- Initialize message list IF p_init_msg_list is set to TRUE.
6727: IF FND_API.to_Boolean( p_init_msg_list ) THEN
6728: FND_MSG_PUB.initialize;
6729: END IF;
6730:
6731: -- Initialize API return status to SUCCESS
6732: x_return_status := FND_API.G_RET_STS_SUCCESS;

Line 6741: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));

6737: if P_LOAN_ID is null then
6738:
6739: FND_MESSAGE.SET_NAME( 'LNS', 'LNS_API_MISSING_COLUMN' );
6740: FND_MESSAGE.SET_TOKEN( 'COLUMN', 'P_LOAN_ID' );
6741: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
6742: RAISE FND_API.G_EXC_ERROR;
6743:
6744: end if;
6745:

Line 6750: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));

6746: if P_LOAN_LINE_ID is null then
6747:
6748: FND_MESSAGE.SET_NAME( 'LNS', 'LNS_API_MISSING_COLUMN' );
6749: FND_MESSAGE.SET_TOKEN( 'COLUMN', 'P_LOAN_LINE_ID' );
6750: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
6751: RAISE FND_API.G_EXC_ERROR;
6752:
6753: end if;
6754:

Line 6784: FND_MSG_PUB.ADD;

6780:
6781: if l_return_status <> 'S' then
6782: FND_MESSAGE.SET_NAME('LNS', 'LNS_CHK_UPG_FAIL');
6783: FND_MESSAGE.SET_TOKEN('DOC_NUM', l_trx_number);
6784: FND_MSG_PUB.ADD;
6785: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
6786: RAISE FND_API.G_EXC_ERROR;
6787: else
6788: if l_upgrade_status <> 'Y' then

Line 6785: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));

6781: if l_return_status <> 'S' then
6782: FND_MESSAGE.SET_NAME('LNS', 'LNS_CHK_UPG_FAIL');
6783: FND_MESSAGE.SET_TOKEN('DOC_NUM', l_trx_number);
6784: FND_MSG_PUB.ADD;
6785: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
6786: RAISE FND_API.G_EXC_ERROR;
6787: else
6788: if l_upgrade_status <> 'Y' then
6789: FND_MESSAGE.SET_NAME('LNS', 'LNS_INVALID_TRX');

Line 6791: FND_MSG_PUB.ADD;

6787: else
6788: if l_upgrade_status <> 'Y' then
6789: FND_MESSAGE.SET_NAME('LNS', 'LNS_INVALID_TRX');
6790: FND_MESSAGE.SET_TOKEN('DOC_NUM', l_trx_number);
6791: FND_MSG_PUB.ADD;
6792: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
6793: RAISE FND_API.G_EXC_ERROR;
6794: end if;
6795: end if;

Line 6792: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));

6788: if l_upgrade_status <> 'Y' then
6789: FND_MESSAGE.SET_NAME('LNS', 'LNS_INVALID_TRX');
6790: FND_MESSAGE.SET_TOKEN('DOC_NUM', l_trx_number);
6791: FND_MSG_PUB.ADD;
6792: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
6793: RAISE FND_API.G_EXC_ERROR;
6794: end if;
6795: end if;
6796:

Line 6854: FND_MSG_PUB.Add;

6850: l_error_counter := l_error_counter + 1;
6851:
6852: if l_error_counter = 1 then
6853: FND_MESSAGE.SET_NAME('LNS', 'LNS_ONLINE_ACCOUNTING_FAILED');
6854: FND_MSG_PUB.Add;
6855: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
6856: end if;
6857:
6858: FND_MESSAGE.SET_NAME('LNS', 'LNS_ACC_DOC_FAIL');

Line 6855: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));

6851:
6852: if l_error_counter = 1 then
6853: FND_MESSAGE.SET_NAME('LNS', 'LNS_ONLINE_ACCOUNTING_FAILED');
6854: FND_MSG_PUB.Add;
6855: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
6856: end if;
6857:
6858: FND_MESSAGE.SET_NAME('LNS', 'LNS_ACC_DOC_FAIL');
6859: FND_MESSAGE.SET_TOKEN('DOC_NUM', l_invoice_number);

Line 6862: FND_MSG_PUB.Add;

6858: FND_MESSAGE.SET_NAME('LNS', 'LNS_ACC_DOC_FAIL');
6859: FND_MESSAGE.SET_TOKEN('DOC_NUM', l_invoice_number);
6860: FND_MESSAGE.SET_TOKEN('DOC_TYPE', l_entity_code);
6861: FND_MESSAGE.SET_TOKEN('ACC_ERR', l_error_message);
6862: FND_MSG_PUB.Add;
6863: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
6864:
6865: END LOOP;
6866:

Line 6863: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));

6859: FND_MESSAGE.SET_TOKEN('DOC_NUM', l_invoice_number);
6860: FND_MESSAGE.SET_TOKEN('DOC_TYPE', l_entity_code);
6861: FND_MESSAGE.SET_TOKEN('ACC_ERR', l_error_message);
6862: FND_MSG_PUB.Add;
6863: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
6864:
6865: END LOOP;
6866:
6867: close c_acc_errors;

Line 6896: FND_MSG_PUB.ADD;

6892: ,flex_qual_name => 'GL_ACCOUNT'
6893: ,segment_number => l_nat_acct_seg_number))
6894: THEN
6895: FND_MESSAGE.SET_NAME('LNS', 'LNS_NO_NATURAL_ACCOUNT_SEGMENT');
6896: FND_MSG_PUB.ADD;
6897: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
6898: RAISE FND_API.G_EXC_ERROR;
6899: END IF;
6900: logMessage(FND_LOG.level_statement, G_PKG_NAME, 'Natural acct segment = ' || l_nat_acct_seg_number);

Line 6897: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));

6893: ,segment_number => l_nat_acct_seg_number))
6894: THEN
6895: FND_MESSAGE.SET_NAME('LNS', 'LNS_NO_NATURAL_ACCOUNT_SEGMENT');
6896: FND_MSG_PUB.ADD;
6897: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
6898: RAISE FND_API.G_EXC_ERROR;
6899: END IF;
6900: logMessage(FND_LOG.level_statement, G_PKG_NAME, 'Natural acct segment = ' || l_nat_acct_seg_number);
6901: END IF;

Line 6940: FND_MSG_PUB.ADD;

6936: exception
6937: when others then
6938: --logMessage(FND_LOG.LEVEL_UNEX, G_PKG_NAME, 'Failed to inherit receivables distributions');
6939: FND_MESSAGE.SET_NAME('LNS', 'LNS_INHERIT_DIST_NOT_FOUND');
6940: FND_MSG_PUB.ADD;
6941: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
6942: RAISE FND_API.G_EXC_ERROR;
6943: end;
6944:

Line 6941: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));

6937: when others then
6938: --logMessage(FND_LOG.LEVEL_UNEX, G_PKG_NAME, 'Failed to inherit receivables distributions');
6939: FND_MESSAGE.SET_NAME('LNS', 'LNS_INHERIT_DIST_NOT_FOUND');
6940: FND_MSG_PUB.ADD;
6941: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
6942: RAISE FND_API.G_EXC_ERROR;
6943: end;
6944:
6945: -- if the adjustment exists in PSA table it means loan is approved and adjustment was created for receivables

Line 7122: FND_MSG_PUB.ADD;

7118: exception
7119: when others then
7120: -- logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, 'failed to inherit receivables distributions');
7121: FND_MESSAGE.SET_NAME('LNS', 'LNS_INHERIT_DIST_NOT_FOUND');
7122: FND_MSG_PUB.ADD;
7123: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
7124: RAISE FND_API.G_EXC_ERROR;
7125: end;
7126:

Line 7123: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));

7119: when others then
7120: -- logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, 'failed to inherit receivables distributions');
7121: FND_MESSAGE.SET_NAME('LNS', 'LNS_INHERIT_DIST_NOT_FOUND');
7122: FND_MSG_PUB.ADD;
7123: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
7124: RAISE FND_API.G_EXC_ERROR;
7125: end;
7126:
7127: else

Line 7221: FND_MSG_PUB.ADD;

7217: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'l_return_status = ' || l_return_status);
7218:
7219: IF l_return_status <> FND_API.G_RET_STS_SUCCESS THEN
7220: FND_MESSAGE.SET_NAME('LNS', 'LNS_ACCOUNTING_EVENT_ERROR');
7221: FND_MSG_PUB.ADD;
7222: --l_last_api_called := 'LNS_XLA_EVENTS.create_event';
7223: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
7224: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
7225: END IF;

Line 7223: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));

7219: IF l_return_status <> FND_API.G_RET_STS_SUCCESS THEN
7220: FND_MESSAGE.SET_NAME('LNS', 'LNS_ACCOUNTING_EVENT_ERROR');
7221: FND_MSG_PUB.ADD;
7222: --l_last_api_called := 'LNS_XLA_EVENTS.create_event';
7223: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
7224: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
7225: END IF;
7226:
7227: if l_event_id is not null then

Line 7244: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);

7240: THEN
7241: COMMIT WORK;
7242: END IF;
7243:
7244: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
7245:
7246: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, l_api_name || ' - END');
7247:
7248: EXCEPTION

Line 7254: FND_MSG_PUB.ADD;

7250: WHEN FND_API.G_EXC_ERROR THEN
7251: x_return_status := FND_API.G_RET_STS_ERROR;
7252: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
7253: FND_MESSAGE.SET_NAME('LNS', 'LNS_ADD_REC_ACC_FAIL');
7254: FND_MSG_PUB.ADD;
7255: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
7256: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
7257: ROLLBACK TO createDistrForAddRec;
7258:

Line 7255: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);

7251: x_return_status := FND_API.G_RET_STS_ERROR;
7252: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
7253: FND_MESSAGE.SET_NAME('LNS', 'LNS_ADD_REC_ACC_FAIL');
7254: FND_MSG_PUB.ADD;
7255: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
7256: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
7257: ROLLBACK TO createDistrForAddRec;
7258:
7259: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN

Line 7256: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));

7252: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
7253: FND_MESSAGE.SET_NAME('LNS', 'LNS_ADD_REC_ACC_FAIL');
7254: FND_MSG_PUB.ADD;
7255: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
7256: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
7257: ROLLBACK TO createDistrForAddRec;
7258:
7259: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
7260: x_return_status := FND_API.G_RET_STS_ERROR;

Line 7263: FND_MSG_PUB.ADD;

7259: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
7260: x_return_status := FND_API.G_RET_STS_ERROR;
7261: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
7262: FND_MESSAGE.SET_NAME('LNS', 'LNS_ADD_REC_ACC_FAIL');
7263: FND_MSG_PUB.ADD;
7264: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
7265: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
7266: ROLLBACK TO createDistrForAddRec;
7267:

Line 7264: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);

7260: x_return_status := FND_API.G_RET_STS_ERROR;
7261: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
7262: FND_MESSAGE.SET_NAME('LNS', 'LNS_ADD_REC_ACC_FAIL');
7263: FND_MSG_PUB.ADD;
7264: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
7265: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
7266: ROLLBACK TO createDistrForAddRec;
7267:
7268: WHEN OTHERS THEN

Line 7265: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));

7261: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
7262: FND_MESSAGE.SET_NAME('LNS', 'LNS_ADD_REC_ACC_FAIL');
7263: FND_MSG_PUB.ADD;
7264: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
7265: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
7266: ROLLBACK TO createDistrForAddRec;
7267:
7268: WHEN OTHERS THEN
7269: x_return_status := FND_API.G_RET_STS_ERROR;

Line 7272: FND_MSG_PUB.ADD;

7268: WHEN OTHERS THEN
7269: x_return_status := FND_API.G_RET_STS_ERROR;
7270: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
7271: FND_MESSAGE.SET_NAME('LNS', 'LNS_ADD_REC_ACC_FAIL');
7272: FND_MSG_PUB.ADD;
7273: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
7274: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
7275: ROLLBACK TO createDistrForAddRec;
7276:

Line 7273: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);

7269: x_return_status := FND_API.G_RET_STS_ERROR;
7270: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
7271: FND_MESSAGE.SET_NAME('LNS', 'LNS_ADD_REC_ACC_FAIL');
7272: FND_MSG_PUB.ADD;
7273: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
7274: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
7275: ROLLBACK TO createDistrForAddRec;
7276:
7277: end createDistrForAddRec;

Line 7274: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));

7270: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
7271: FND_MESSAGE.SET_NAME('LNS', 'LNS_ADD_REC_ACC_FAIL');
7272: FND_MSG_PUB.ADD;
7273: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
7274: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
7275: ROLLBACK TO createDistrForAddRec;
7276:
7277: end createDistrForAddRec;
7278:

Line 7407: FND_MSG_PUB.initialize;

7403: logMessage(FND_LOG.level_statement, G_PKG_NAME, 'p_loan_id = ' || p_loan_id);
7404:
7405: -- Initialize message list IF p_init_msg_list is set to TRUE.
7406: IF FND_API.to_Boolean( p_init_msg_list ) THEN
7407: FND_MSG_PUB.initialize;
7408: END IF;
7409:
7410: -- Initialize API return status to SUCCESS
7411: x_return_status := FND_API.G_RET_STS_SUCCESS;

Line 7439: FND_MSG_PUB.ADD;

7435: IF l_return_status <> FND_API.G_RET_STS_SUCCESS THEN
7436: FND_MESSAGE.SET_NAME('LNS', 'LNS_INVALID_VALUE');
7437: FND_MESSAGE.SET_TOKEN('PARAMETER', 'LOAN_ID');
7438: FND_MESSAGE.SET_TOKEN('VALUE', p_loan_id);
7439: FND_MSG_PUB.ADD;
7440: RAISE FND_API.G_EXC_ERROR;
7441: END IF;
7442:
7443: OPEN c_loan_info(p_loan_id);

Line 7591: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);

7587: COMMIT;
7588: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, l_api_name || 'Commited');
7589: END IF;
7590:
7591: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
7592: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, l_api_name || ' - END');
7593:
7594: EXCEPTION
7595:

Line 7599: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);

7595:
7596: WHEN FND_API.G_EXC_ERROR THEN
7597: ROLLBACK TO generateCancelDistributions;
7598: x_return_status := FND_API.G_RET_STS_ERROR;
7599: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
7600: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
7601:
7602: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
7603: ROLLBACK TO generateCancelDistributions;

Line 7605: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);

7601:
7602: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
7603: ROLLBACK TO generateCancelDistributions;
7604: x_return_status := FND_API.G_RET_STS_ERROR;
7605: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
7606: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
7607:
7608: WHEN OTHERS THEN
7609: ROLLBACK TO generateCancelDistributions;

Line 7611: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);

7607:
7608: WHEN OTHERS THEN
7609: ROLLBACK TO generateCancelDistributions;
7610: x_return_status := FND_API.G_RET_STS_ERROR;
7611: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
7612: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
7613:
7614: end generateCancelDistributions;
7615:

Line 7690: FND_MSG_PUB.initialize;

7686: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'p_activity ' || p_activity);
7687:
7688: -- Initialize message list IF p_init_msg_list is set to TRUE.
7689: IF FND_API.to_Boolean( p_init_msg_list ) THEN
7690: FND_MSG_PUB.initialize;
7691: END IF;
7692:
7693: -- Initialize API return status to SUCCESS
7694: x_return_status := FND_API.G_RET_STS_SUCCESS;

Line 7784: FND_MSG_PUB.ADD;

7780: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'l_event_id = ' || l_event_id);
7781:
7782: IF x_return_status <> FND_API.G_RET_STS_SUCCESS THEN
7783: FND_MESSAGE.SET_NAME('LNS', 'LNS_ACCOUNTING_EVENT_ERROR');
7784: FND_MSG_PUB.ADD;
7785: logMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
7786: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
7787: END IF;
7788:

Line 7785: logMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));

7781:
7782: IF x_return_status <> FND_API.G_RET_STS_SUCCESS THEN
7783: FND_MESSAGE.SET_NAME('LNS', 'LNS_ACCOUNTING_EVENT_ERROR');
7784: FND_MSG_PUB.ADD;
7785: logMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
7786: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
7787: END IF;
7788:
7789: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'stamping new event_id on distributions');

Line 7833: FND_MSG_PUB.ADD;

7829:
7830: x_return_status := FND_API.G_RET_STS_ERROR;
7831: FND_MESSAGE.SET_NAME('LNS', 'LNS_API_OTHERS_EXCEP');
7832: FND_MESSAGE.SET_TOKEN('ERROR' ,'Call to PSA_BC_XLA_PUB.Budgetary_Control failed with Status Code = ' || l_status_code);
7833: FND_MSG_PUB.ADD;
7834: logMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
7835: RAISE FND_API.G_EXC_ERROR;
7836:
7837: else

Line 7834: logMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));

7830: x_return_status := FND_API.G_RET_STS_ERROR;
7831: FND_MESSAGE.SET_NAME('LNS', 'LNS_API_OTHERS_EXCEP');
7832: FND_MESSAGE.SET_TOKEN('ERROR' ,'Call to PSA_BC_XLA_PUB.Budgetary_Control failed with Status Code = ' || l_status_code);
7833: FND_MSG_PUB.ADD;
7834: logMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
7835: RAISE FND_API.G_EXC_ERROR;
7836:
7837: else
7838: -- caller handle success status

Line 7862: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);

7858: WHEN FND_API.G_EXC_ERROR THEN
7859: ROLLBACK TO cancel_disbursements;
7860: x_return_status := FND_API.G_RET_STS_ERROR;
7861: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
7862: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
7863:
7864: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
7865: ROLLBACK TO cancel_disbursements;
7866: x_return_status := FND_API.G_RET_STS_ERROR;

Line 7868: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);

7864: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
7865: ROLLBACK TO cancel_disbursements;
7866: x_return_status := FND_API.G_RET_STS_ERROR;
7867: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
7868: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
7869:
7870: WHEN OTHERS THEN
7871: ROLLBACK TO cancel_disbursements;
7872: x_return_status := FND_API.G_RET_STS_ERROR;

Line 7874: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);

7870: WHEN OTHERS THEN
7871: ROLLBACK TO cancel_disbursements;
7872: x_return_status := FND_API.G_RET_STS_ERROR;
7873: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
7874: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
7875:
7876: end submit_disbursement_bc;
7877:
7878: /*========================================================================

Line 8272: fnd_msg_pub.get(l_indexNo, 'F', l_error, l_index);

8268: l_statement2 := l_statement2 || l_new_line;
8269:
8270: IF P_RESULT in ( 'E', 'W') THEN
8271: WHILE (l_indexNo <= P_ERR_COUNT ) LOOP
8272: fnd_msg_pub.get(l_indexNo, 'F', l_error, l_index);
8273: l_error := LNS_REP_UTILS.REPLACE_SPECIAL_CHARS(l_error);
8274: l_err_msg:= l_err_msg || l_error;
8275: l_indexNo := l_indexNo + 1;
8276: END LOOP;

Line 8373: fnd_msg_pub.get(l_indexNo, 'F', l_error, l_index);

8369:
8370: /* build error statement */
8371:
8372: WHILE (l_indexNo <= P_ERR_COUNT ) LOOP
8373: fnd_msg_pub.get(l_indexNo, 'F', l_error, l_index);
8374: l_error := LNS_REP_UTILS.REPLACE_SPECIAL_CHARS(l_error);
8375: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'l_error: ' || l_error);
8376: l_err_msg := l_err_msg || l_error;
8377: l_indexNo := l_indexNo + 1;

Line 8520: FND_MSG_PUB.initialize;

8516:
8517:
8518: -- Initialize message list IF p_init_msg_list is set to TRUE.
8519: IF FND_API.to_Boolean( p_init_msg_list ) THEN
8520: FND_MSG_PUB.initialize;
8521: END IF;
8522:
8523: -- Initialize API return status to SUCCESS
8524: x_return_status := FND_API.G_RET_STS_SUCCESS;

Line 8660: FND_MSG_PUB.Add;

8656:
8657: FND_MESSAGE.SET_NAME('LNS', 'LNS_ACCRUED_ALREADY');
8658: FND_MESSAGE.SET_TOKEN('LOAN_NUMBER', l_loan_num);
8659: FND_MESSAGE.SET_TOKEN('LAST_ACCRUAL_DATE', p_accrual_date);
8660: FND_MSG_PUB.Add;
8661: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
8662:
8663: RAISE FND_API.G_EXC_ERROR;
8664:

Line 8661: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));

8657: FND_MESSAGE.SET_NAME('LNS', 'LNS_ACCRUED_ALREADY');
8658: FND_MESSAGE.SET_TOKEN('LOAN_NUMBER', l_loan_num);
8659: FND_MESSAGE.SET_TOKEN('LAST_ACCRUAL_DATE', p_accrual_date);
8660: FND_MSG_PUB.Add;
8661: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
8662:
8663: RAISE FND_API.G_EXC_ERROR;
8664:
8665: END IF; -- IF l_exists == 0

Line 8674: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);

8670: COMMIT;
8671: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, l_api_name || 'Commited');
8672: END IF;
8673:
8674: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
8675: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, l_api_name || ' - END');
8676:
8677: EXCEPTION
8678:

Line 8683: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);

8679: WHEN FND_API.G_EXC_ERROR THEN
8680: ROLLBACK TO create_AccrualDistribs;
8681: x_return_status := FND_API.G_RET_STS_ERROR;
8682: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
8683: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
8684:
8685: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
8686: ROLLBACK TO create_AccrualDistribs;
8687: x_return_status := FND_API.G_RET_STS_ERROR;

Line 8689: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);

8685: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
8686: ROLLBACK TO create_AccrualDistribs;
8687: x_return_status := FND_API.G_RET_STS_ERROR;
8688: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
8689: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
8690:
8691: WHEN OTHERS THEN
8692: ROLLBACK TO create_AccrualDistribs;
8693: x_return_status := FND_API.G_RET_STS_ERROR;

Line 8695: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);

8691: WHEN OTHERS THEN
8692: ROLLBACK TO create_AccrualDistribs;
8693: x_return_status := FND_API.G_RET_STS_ERROR;
8694: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
8695: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
8696:
8697: END create_AccrualDistribs;
8698:
8699: /*========================================================================

Line 9146: FND_MSG_PUB.initialize;

9142:
9143:
9144: -- Initialize message list IF p_init_msg_list is set to TRUE.
9145: IF FND_API.to_Boolean( p_init_msg_list ) THEN
9146: FND_MSG_PUB.initialize;
9147: END IF;
9148:
9149: -- Initialize API return status to SUCCESS
9150: x_return_status := FND_API.G_RET_STS_SUCCESS;

Line 9191: FND_MSG_PUB.Add;

9187:
9188: IF l_disable_int_accrual_flag = 'Y' THEN
9189: FND_MESSAGE.SET_NAME('LNS', 'LNS_ACCRUAL_DISABLED');
9190: FND_MESSAGE.SET_TOKEN('LOAN_NUMBER', l_loan_num);
9191: FND_MSG_PUB.Add;
9192: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
9193:
9194: RAISE FND_API.G_EXC_ERROR;
9195: END IF;

Line 9192: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));

9188: IF l_disable_int_accrual_flag = 'Y' THEN
9189: FND_MESSAGE.SET_NAME('LNS', 'LNS_ACCRUAL_DISABLED');
9190: FND_MESSAGE.SET_TOKEN('LOAN_NUMBER', l_loan_num);
9191: FND_MSG_PUB.Add;
9192: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
9193:
9194: RAISE FND_API.G_EXC_ERROR;
9195: END IF;
9196:

Line 9202: FND_MSG_PUB.Add;

9198:
9199: FND_MESSAGE.SET_NAME('LNS', 'LNS_ACCRUED_ALREADY');
9200: FND_MESSAGE.SET_TOKEN('LOAN_NUMBER', l_loan_num);
9201: FND_MESSAGE.SET_TOKEN('LAST_ACCRUAL_DATE', l_last_accrued_date);
9202: FND_MSG_PUB.Add;
9203: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
9204:
9205: RAISE FND_API.G_EXC_ERROR;
9206: END IF;

Line 9203: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));

9199: FND_MESSAGE.SET_NAME('LNS', 'LNS_ACCRUED_ALREADY');
9200: FND_MESSAGE.SET_TOKEN('LOAN_NUMBER', l_loan_num);
9201: FND_MESSAGE.SET_TOKEN('LAST_ACCRUAL_DATE', l_last_accrued_date);
9202: FND_MSG_PUB.Add;
9203: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
9204:
9205: RAISE FND_API.G_EXC_ERROR;
9206: END IF;
9207:

Line 9248: FND_MSG_PUB.Add;

9244: IF l_event_status_code in ('P', 'R') THEN
9245: FND_MESSAGE.SET_NAME('LNS', 'LNS_ACCRUAL_FINAL_ACCOUNTED');
9246: FND_MESSAGE.SET_TOKEN('LOAN_NUMBER', l_loan_num);
9247: -- FND_MESSAGE.SET_TOKEN('LAST_ACCRUAL_DATE', l_last_accrued_date);
9248: FND_MSG_PUB.Add;
9249: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
9250:
9251: RAISE FND_API.G_EXC_ERROR;
9252: ELSE

Line 9249: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));

9245: FND_MESSAGE.SET_NAME('LNS', 'LNS_ACCRUAL_FINAL_ACCOUNTED');
9246: FND_MESSAGE.SET_TOKEN('LOAN_NUMBER', l_loan_num);
9247: -- FND_MESSAGE.SET_TOKEN('LAST_ACCRUAL_DATE', l_last_accrued_date);
9248: FND_MSG_PUB.Add;
9249: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
9250:
9251: RAISE FND_API.G_EXC_ERROR;
9252: ELSE
9253: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Deleting the event_id '||l_exist_event_id);

Line 9341: FND_MSG_PUB.ADD;

9337: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'x_event_id ' || l_event_id);
9338:
9339: IF l_return_status <> FND_API.G_RET_STS_SUCCESS THEN
9340: FND_MESSAGE.SET_NAME('LNS', 'LNS_ACCOUNTING_EVENT_ERROR');
9341: FND_MSG_PUB.ADD;
9342: logMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
9343: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
9344: END IF;
9345:

Line 9342: logMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));

9338:
9339: IF l_return_status <> FND_API.G_RET_STS_SUCCESS THEN
9340: FND_MESSAGE.SET_NAME('LNS', 'LNS_ACCOUNTING_EVENT_ERROR');
9341: FND_MSG_PUB.ADD;
9342: logMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
9343: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
9344: END IF;
9345:
9346: --3. stamp the eventID onto the lns_distributions table

Line 9446: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);

9442: COMMIT;
9443: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, l_api_name || 'Commited');
9444: END IF;
9445:
9446: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
9447: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, l_api_name || ' - END');
9448:
9449: EXCEPTION
9450:

Line 9454: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);

9450:
9451: WHEN G_EXC_WARNING THEN
9452: ROLLBACK TO do_int_accrual_reversal;
9453: x_return_status := FND_API.G_RET_STS_ERROR;
9454: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
9455: LogMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, 'Rollbacked loan_id ' || P_LOAN_ID);
9456: g_cr_return_status := 'WARNING';
9457: /* building error statement */
9458: BUILD_ACCRUAL_STMT(P_LOAN_ID => P_LOAN_ID

Line 9469: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);

9465:
9466: WHEN FND_API.G_EXC_ERROR THEN
9467: ROLLBACK TO do_int_accrual_reversal;
9468: x_return_status := FND_API.G_RET_STS_ERROR;
9469: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
9470: LogMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, 'Rollbacked loan_id ' || P_LOAN_ID);
9471: g_cr_return_status := 'WARNING';
9472: /* building error statement */
9473: BUILD_ACCRUAL_STMT(P_LOAN_ID => P_LOAN_ID

Line 9485: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);

9481: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
9482: ROLLBACK TO do_int_accrual_reversal;
9483: x_return_status := FND_API.G_RET_STS_ERROR;
9484: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
9485: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
9486: LogMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, 'Rollbacked loan_id ' || P_LOAN_ID);
9487: g_cr_return_status := 'WARNING';
9488: /* building error statement */
9489: BUILD_ACCRUAL_STMT(P_LOAN_ID => P_LOAN_ID

Line 9501: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);

9497: WHEN OTHERS THEN
9498: ROLLBACK TO do_int_accrual_reversal;
9499: x_return_status := FND_API.G_RET_STS_ERROR;
9500: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
9501: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
9502: LogMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, 'Rollbacked loan_id ' || P_LOAN_ID);
9503: g_cr_return_status := 'WARNING';
9504: /* building error statement */
9505: BUILD_ACCRUAL_STMT(P_LOAN_ID => P_LOAN_ID

Line 9668: FND_MSG_PUB.initialize;

9664: END IF;
9665:
9666: -- Initialize message list if p_init_msg_list is set to TRUE
9667: IF FND_API.To_Boolean(p_init_msg_list) THEN
9668: FND_MSG_PUB.initialize;
9669: END IF;
9670:
9671: -- Initialize API return status to success
9672: l_return_status := FND_API.G_RET_STS_SUCCESS;

Line 9709: FND_MSG_PUB.Add;

9705:
9706: ELSE
9707:
9708: FND_MESSAGE.SET_NAME('LNS', 'LNS_INVALID_PARAMS');
9709: FND_MSG_PUB.Add;
9710: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
9711: RAISE FND_API.G_EXC_ERROR;
9712:
9713: END IF;

Line 9710: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));

9706: ELSE
9707:
9708: FND_MESSAGE.SET_NAME('LNS', 'LNS_INVALID_PARAMS');
9709: FND_MSG_PUB.Add;
9710: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
9711: RAISE FND_API.G_EXC_ERROR;
9712:
9713: END IF;
9714:

Line 9751: FND_MSG_PUB.Add;

9747: l_accrual_date := p_accrual_date;
9748: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'It is NOT Period End Accrual - l_is_period_end: '||l_is_period_end );
9749: ELSE
9750: FND_MESSAGE.SET_NAME('LNS', 'LNS_INVALID_PARAMS');
9751: FND_MSG_PUB.Add;
9752: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
9753: RAISE FND_API.G_EXC_ERROR;
9754: END IF;
9755:

Line 9752: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));

9748: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'It is NOT Period End Accrual - l_is_period_end: '||l_is_period_end );
9749: ELSE
9750: FND_MESSAGE.SET_NAME('LNS', 'LNS_INVALID_PARAMS');
9751: FND_MSG_PUB.Add;
9752: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
9753: RAISE FND_API.G_EXC_ERROR;
9754: END IF;
9755:
9756: IF l_is_period_end = 'Y' THEN

Line 9769: FND_MSG_PUB.Add;

9765:
9766: IF l_accrual_date is NULL THEN
9767: FND_MESSAGE.SET_NAME('LNS', 'LNS_INVALID_PERIOD');
9768: FND_MESSAGE.SET_TOKEN('PERIOD_NAME',p_period_name);
9769: FND_MSG_PUB.Add;
9770: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
9771: RAISE FND_API.G_EXC_ERROR;
9772: END IF;
9773:

Line 9770: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));

9766: IF l_accrual_date is NULL THEN
9767: FND_MESSAGE.SET_NAME('LNS', 'LNS_INVALID_PERIOD');
9768: FND_MESSAGE.SET_TOKEN('PERIOD_NAME',p_period_name);
9769: FND_MSG_PUB.Add;
9770: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
9771: RAISE FND_API.G_EXC_ERROR;
9772: END IF;
9773:
9774: END IF;

Line 9791: FND_MSG_PUB.Add;

9787:
9788: IF l_gl_period_status NOT IN ( 'O') THEN
9789: FND_MESSAGE.SET_NAME('LNS', 'LNS_ACCRUE_GL_PERIOD_CLOSED');
9790: FND_MESSAGE.SET_TOKEN('ACCRUAL_DATE', l_accrual_date);
9791: FND_MSG_PUB.Add;
9792: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
9793: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Invoking BUILD_ACCRUAL_ERR_STMT() API');
9794: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
9795: BUILD_ACCRUAL_ERR_STMT(P_ACCRUAL_DATE => l_accrual_date

Line 9792: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));

9788: IF l_gl_period_status NOT IN ( 'O') THEN
9789: FND_MESSAGE.SET_NAME('LNS', 'LNS_ACCRUE_GL_PERIOD_CLOSED');
9790: FND_MESSAGE.SET_TOKEN('ACCRUAL_DATE', l_accrual_date);
9791: FND_MSG_PUB.Add;
9792: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
9793: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Invoking BUILD_ACCRUAL_ERR_STMT() API');
9794: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
9795: BUILD_ACCRUAL_ERR_STMT(P_ACCRUAL_DATE => l_accrual_date
9796: ,P_RESULT => 'E'

Line 9794: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);

9790: FND_MESSAGE.SET_TOKEN('ACCRUAL_DATE', l_accrual_date);
9791: FND_MSG_PUB.Add;
9792: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
9793: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Invoking BUILD_ACCRUAL_ERR_STMT() API');
9794: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
9795: BUILD_ACCRUAL_ERR_STMT(P_ACCRUAL_DATE => l_accrual_date
9796: ,P_RESULT => 'E'
9797: ,P_ERR_COUNT => x_msg_count
9798: ,X_STATEMENT_XML => l_error_statements_xml);

Line 9913: FND_MSG_PUB.Count_And_Get(

9909: -- END OF BODY OF API
9910: x_return_status := FND_API.G_RET_STS_SUCCESS;
9911:
9912: -- Standard call to get message count and if count is 1, get message info
9913: FND_MSG_PUB.Count_And_Get(
9914: p_encoded => FND_API.G_FALSE,
9915: p_count => x_msg_count,
9916: p_data => x_msg_data);
9917:

Line 9924: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);

9920: EXCEPTION
9921: WHEN FND_API.G_EXC_ERROR THEN
9922: ROLLBACK TO ACCRUE_LOANS_INTEREST_PVT;
9923: x_return_status := FND_API.G_RET_STS_ERROR;
9924: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
9925: LogMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, 'Rollbacked loans');
9926: g_cr_return_status := 'ERROR';
9927: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
9928: ROLLBACK TO ACCRUE_LOANS_INTEREST_PVT;

Line 9930: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);

9926: g_cr_return_status := 'ERROR';
9927: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
9928: ROLLBACK TO ACCRUE_LOANS_INTEREST_PVT;
9929: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
9930: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
9931: LogMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, 'Rollbacked loans');
9932: g_cr_return_status := 'ERROR';
9933: WHEN OTHERS THEN
9934: ROLLBACK TO ACCRUE_LOANS_INTEREST_PVT;

Line 9936: IF FND_MSG_PUB.Check_Msg_Level(FND_MSG_PUB.G_MSG_LVL_UNEXP_ERROR)THEN

9932: g_cr_return_status := 'ERROR';
9933: WHEN OTHERS THEN
9934: ROLLBACK TO ACCRUE_LOANS_INTEREST_PVT;
9935: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
9936: IF FND_MSG_PUB.Check_Msg_Level(FND_MSG_PUB.G_MSG_LVL_UNEXP_ERROR)THEN
9937: FND_MSG_PUB.Add_Exc_Msg(G_PKG_NAME, l_api_name);
9938: END IF;
9939: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
9940: LogMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, 'Rollbacked loans');

Line 9937: FND_MSG_PUB.Add_Exc_Msg(G_PKG_NAME, l_api_name);

9933: WHEN OTHERS THEN
9934: ROLLBACK TO ACCRUE_LOANS_INTEREST_PVT;
9935: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
9936: IF FND_MSG_PUB.Check_Msg_Level(FND_MSG_PUB.G_MSG_LVL_UNEXP_ERROR)THEN
9937: FND_MSG_PUB.Add_Exc_Msg(G_PKG_NAME, l_api_name);
9938: END IF;
9939: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
9940: LogMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, 'Rollbacked loans');
9941: g_cr_return_status := 'ERROR';

Line 9939: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);

9935: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
9936: IF FND_MSG_PUB.Check_Msg_Level(FND_MSG_PUB.G_MSG_LVL_UNEXP_ERROR)THEN
9937: FND_MSG_PUB.Add_Exc_Msg(G_PKG_NAME, l_api_name);
9938: END IF;
9939: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
9940: LogMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, 'Rollbacked loans');
9941: g_cr_return_status := 'ERROR';
9942:
9943: END ACCRUE_LOANS_INTEREST;

Line 10213: FND_MSG_PUB.initialize;

10209: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'p_activity = ' || p_activity);
10210:
10211: -- Initialize message list IF p_init_msg_list is set to TRUE.
10212: IF FND_API.to_Boolean( p_init_msg_list ) THEN
10213: FND_MSG_PUB.initialize;
10214: END IF;
10215:
10216: -- Initialize API return status to SUCCESS
10217: x_return_status := FND_API.G_RET_STS_SUCCESS;

Line 10344: FND_MSG_PUB.ADD;

10340:
10341: EXCEPTION
10342: when no_data_found then
10343: FND_MESSAGE.SET_NAME('LNS', 'LNS_DEFAULT_DIST_NOT_FOUND');
10344: FND_MSG_PUB.ADD;
10345: logMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
10346: RAISE FND_API.G_EXC_ERROR;
10347: END; -- c_default_info cursor
10348:

Line 10345: logMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));

10341: EXCEPTION
10342: when no_data_found then
10343: FND_MESSAGE.SET_NAME('LNS', 'LNS_DEFAULT_DIST_NOT_FOUND');
10344: FND_MSG_PUB.ADD;
10345: logMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
10346: RAISE FND_API.G_EXC_ERROR;
10347: END; -- c_default_info cursor
10348:
10349: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'distribs2 count is ' || l_distributions.count);

Line 10357: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);

10353: THEN
10354: COMMIT WORK;
10355: END IF;
10356:
10357: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
10358:
10359: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, l_api_name || ' - END');
10360:
10361: EXCEPTION

Line 10366: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);

10362: WHEN FND_API.G_EXC_ERROR THEN
10363: ROLLBACK TO defaultBookDistForActivity;
10364: x_return_status := FND_API.G_RET_STS_ERROR;
10365: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
10366: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
10367:
10368: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
10369: ROLLBACK TO defaultBookDistForActivity;
10370: x_return_status := FND_API.G_RET_STS_ERROR;

Line 10372: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);

10368: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
10369: ROLLBACK TO defaultBookDistForActivity;
10370: x_return_status := FND_API.G_RET_STS_ERROR;
10371: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
10372: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
10373:
10374: WHEN OTHERS THEN
10375: ROLLBACK TO defaultBookDistForActivity;
10376: x_return_status := FND_API.G_RET_STS_ERROR;

Line 10378: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);

10374: WHEN OTHERS THEN
10375: ROLLBACK TO defaultBookDistForActivity;
10376: x_return_status := FND_API.G_RET_STS_ERROR;
10377: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
10378: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
10379:
10380: END defaultBookDistForActivity;
10381:
10382: /*=========================================================================

Line 10740: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);

10736:
10737: WHEN OTHERS THEN
10738: x_return_status := FND_API.G_RET_STS_ERROR;
10739: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
10740: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
10741: RAISE;
10742:
10743: END GENERATE_CCID_FOR_PROJECTS;
10744: