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.

[Home] [Help]

APPS.LNS_DISTRIBUTIONS_PUB dependencies on FND_API

Line 99: IF FND_API.to_Boolean( p_init_msg_list ) THEN

95: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, l_api_name || ' - BEGIN');
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

Line 104: x_return_status := FND_API.G_RET_STS_SUCCESS;

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;
105:
106: -- first complete accounting for any unprocessed events / documents for the loan transaction
107: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Calling lns_distributions_pub.onlineAccounting...');
108: lns_distributions_pub.onlineAccounting(p_loan_id => p_loan_id

Line 109: ,p_init_msg_list => fnd_api.g_false

105:
106: -- first complete accounting for any unprocessed events / documents for the loan transaction
107: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Calling lns_distributions_pub.onlineAccounting...');
108: lns_distributions_pub.onlineAccounting(p_loan_id => p_loan_id
109: ,p_init_msg_list => fnd_api.g_false
110: ,p_accounting_mode => 'F'
111: ,p_transfer_flag => 'Y'
112: ,p_offline_flag => 'N'
113: ,p_gl_posting_flag => 'N'

Line 119: RAISE FND_API.G_EXC_ERROR;

115: ,x_msg_count => l_msg_count
116: ,x_msg_data => l_msg_data);
117: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'l_return_status = ' || l_return_status);
118: if l_return_status <> 'S' then
119: RAISE FND_API.G_EXC_ERROR;
120: end if;
121:
122:
123:

Line 145: RAISE FND_API.G_EXC_ERROR;

141: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'GenerateCancelDistribs - l_return_status = ' || l_return_status);
142:
143: IF l_return_status <> 'S' THEN
144: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, l_api_name || ' generateCancelDistributions failed with error '||l_msg_data);
145: RAISE FND_API.G_EXC_ERROR;
146: END IF;
147:
148: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'federal enabled');
149: open c_budget_req(p_loan_id);

Line 163: ,p_init_msg_list => fnd_api.g_false

159: ,p_loan_amount_adj_id => -1
160: ,p_event_type_code => 'FUTURE_DISBURSEMENT_CANCELLED'
161: ,p_event_date => l_gl_date
162: ,p_event_status => 'U'
163: ,p_init_msg_list => fnd_api.g_false
164: ,p_commit => fnd_api.g_false
165: ,p_bc_flag => 'Y'
166: ,x_event_id => l_event_id
167: ,x_return_status => l_return_status

Line 164: ,p_commit => fnd_api.g_false

160: ,p_event_type_code => 'FUTURE_DISBURSEMENT_CANCELLED'
161: ,p_event_date => l_gl_date
162: ,p_event_status => 'U'
163: ,p_init_msg_list => fnd_api.g_false
164: ,p_commit => fnd_api.g_false
165: ,p_bc_flag => 'Y'
166: ,x_event_id => l_event_id
167: ,x_return_status => l_return_status
168: ,x_msg_count => l_msg_count

Line 173: IF x_return_status <> FND_API.G_RET_STS_SUCCESS THEN

169: ,x_msg_data => l_msg_data);
170: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'l_return_status = ' || l_return_status);
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;

Line 177: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;

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');
181: update lns_distributions

Line 200: ,p_init_msg_list => FND_API.G_FALSE

196:
197: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Calling PSA_BC_XLA_PUB.Budgetary_Control ' || l_event_id);
198: -- always pass P_BC_MODE = reserve as per shaniqua williams
199: PSA_BC_XLA_PUB.Budgetary_Control(p_api_version => 1.0
200: ,p_init_msg_list => FND_API.G_FALSE
201: ,x_return_status => l_return_status
202: ,x_msg_count => l_msg_count
203: ,x_msg_data => l_msg_data
204: ,p_application_id => 206

Line 219: x_return_status := FND_API.G_RET_STS_ERROR;

215:
216: -- we want to commit ONLY in the case of SUCCESS or ADVISORY
217: if (l_return_status <> 'S') then
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'));

Line 224: RAISE FND_API.G_EXC_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
228: null;

Line 237: IF FND_API.to_Boolean(p_commit)

233:
234: end if;
235:
236: x_return_status := l_return_status;
237: IF FND_API.to_Boolean(p_commit)
238: THEN
239: COMMIT WORK;
240: END IF;
241:

Line 246: WHEN FND_API.G_EXC_ERROR THEN

242: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, l_api_name || ' - END');
243:
244: EXCEPTION
245:
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);

Line 248: x_return_status := FND_API.G_RET_STS_ERROR;

244: EXCEPTION
245:
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

Line 252: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN

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;
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);

Line 254: x_return_status := FND_API.G_RET_STS_ERROR;

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;
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

Line 260: x_return_status := FND_API.G_RET_STS_ERROR;

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;
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;

Line 371: if l_return_status <> FND_API.G_RET_STS_SUCCESS then

367: ,p_col_id => p_loan_id
368: ,p_col_name => 'LOAN_ID'
369: ,p_table_name => 'LNS_LOAN_HEADERS');
370:
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;

Line 376: RAISE FND_API.G_EXC_ERROR;

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);
380: FETCH c_loan_adj INTO l_loan_amount_adj_id;

Line 401: if l_return_status <> FND_API.G_RET_STS_SUCCESS then

397: ,p_col_id => p_loan_amount_adj_id
398: ,p_col_name => 'LOAN_AMOUNT_ADJ_ID'
399: ,p_table_name => 'LNS_LOAN_AMOUNT_ADJS');
400:
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;

Line 406: RAISE FND_API.G_EXC_ERROR;

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;
410:

Line 571: IF FND_API.to_Boolean( p_init_msg_list ) THEN

567: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'p_loan_id = ' || p_loan_id);
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

Line 576: x_return_status := FND_API.G_RET_STS_SUCCESS;

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;
577:
578: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'fetching l_disbusement_id ');
579: open c_disbursements(p_loan_id);
580: fetch c_disbursements into l_disbursement_id;

Line 592: RAISE FND_API.G_EXC_ERROR;

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
596:

Line 619: ,p_init_msg_list => fnd_api.g_false

615: ,p_loan_amount_adj_id => -1
616: ,p_event_type_code => 'DIRECT_LOAN_APPROVED'
617: ,p_event_date => l_gl_date
618: ,p_event_status => 'U'
619: ,p_init_msg_list => fnd_api.g_false
620: ,p_commit => fnd_api.g_false
621: ,p_bc_flag => 'Y'
622: ,x_event_id => x_event_id
623: ,x_return_status => x_return_status

Line 620: ,p_commit => fnd_api.g_false

616: ,p_event_type_code => 'DIRECT_LOAN_APPROVED'
617: ,p_event_date => l_gl_date
618: ,p_event_status => 'U'
619: ,p_init_msg_list => fnd_api.g_false
620: ,p_commit => fnd_api.g_false
621: ,p_bc_flag => 'Y'
622: ,x_event_id => x_event_id
623: ,x_return_status => x_return_status
624: ,x_msg_count => x_msg_count

Line 629: IF x_return_status <> FND_API.G_RET_STS_SUCCESS THEN

625: ,x_msg_data => x_msg_data);
626: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'x_return_status = ' || x_return_status);
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;

Line 633: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;

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
637: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'stamping eventID on lns_distributions');

Line 683: ,p_init_msg_list => FND_API.G_FALSE

679: values (l_event_id, 'FAIL');
680:
681: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Calling PSA_BC_XLA_PUB.Budgetary_Control ' || l_event_id);
682: PSA_BC_XLA_PUB.Budgetary_Control(p_api_version => 1.0
683: ,p_init_msg_list => FND_API.G_FALSE
684: ,x_return_status => l_return_status
685: ,x_msg_count => l_msg_count
686: ,x_msg_data => l_msg_data
687: ,p_application_id => 206

Line 704: l_return_status := FND_API.G_RET_STS_ERROR;

700: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, l_api_name || ' l_packet_id = ' || l_packet_id);
701:
702: if (l_return_status <> 'S' ) then
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'));

Line 709: RAISE FND_API.G_EXC_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);
713:

Line 740: RAISE FND_API.G_EXC_ERROR;

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);
744: FND_MSG_PUB.ADD;

Line 746: RAISE FND_API.G_EXC_ERROR;

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: */
750: if p_budgetary_control_mode = 'R' then

Line 769: ,P_INIT_MSG_LIST => FND_API.G_FALSE

765: l_loan_header_rec.FUNDS_CHECK_DATE := sysdate;
766: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, l_api_name || ' - updating loan');
767: LNS_LOAN_HEADER_PUB.UPDATE_LOAN(P_OBJECT_VERSION_NUMBER => l_version
768: ,P_LOAN_HEADER_REC => l_loan_header_rec
769: ,P_INIT_MSG_LIST => FND_API.G_FALSE
770: ,X_RETURN_STATUS => l_return_status
771: ,X_MSG_COUNT => l_msg_count
772: ,X_MSG_DATA => l_msg_data);
773: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'update loan status = ' || l_return_status);

Line 779: RAISE FND_API.G_EXC_ERROR;

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
783:

Line 788: IF (l_return_status = 'S' AND FND_API.to_Boolean(p_commit))

784: end if; -- l_funds_reserved_flag
785: x_budgetary_status_code := l_status_code;
786: x_return_status := l_return_status;
787:
788: IF (l_return_status = 'S' AND FND_API.to_Boolean(p_commit))
789: THEN
790: COMMIT WORK;
791: END IF;
792:

Line 799: WHEN FND_API.G_EXC_ERROR THEN

795: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, l_api_name || ' - END');
796:
797: EXCEPTION
798:
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);

Line 801: x_return_status := FND_API.G_RET_STS_ERROR;

797: EXCEPTION
798:
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

Line 805: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN

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;
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);

Line 807: x_return_status := FND_API.G_RET_STS_ERROR;

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;
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

Line 813: x_return_status := FND_API.G_RET_STS_ERROR;

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;
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;

Line 947: RAISE FND_API.G_EXC_ERROR;

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');
951:

Line 1116: IF FND_API.to_Boolean( p_init_msg_list ) THEN

1112: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'p_include_loan_receivables = ' || p_include_loan_receivables);
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

Line 1121: x_return_status := FND_API.G_RET_STS_SUCCESS;

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;
1122:
1123: n := 0;
1124: k := 0;
1125: l := 0;

Line 1338: RAISE FND_API.G_EXC_ERROR;

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);
1342: x_distribution_tbl := l_distributions;

Line 1344: IF FND_API.to_Boolean(p_commit)

1340:
1341: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'distribs2 count is ' || l_distributions.count);
1342: x_distribution_tbl := l_distributions;
1343:
1344: IF FND_API.to_Boolean(p_commit)
1345: THEN
1346: COMMIT WORK;
1347: END IF;
1348:

Line 1354: WHEN FND_API.G_EXC_ERROR THEN

1350:
1351: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, l_api_name || ' - END');
1352:
1353: EXCEPTION
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);

Line 1356: x_return_status := FND_API.G_RET_STS_ERROR;

1352:
1353: EXCEPTION
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

Line 1360: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN

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;
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);

Line 1362: x_return_status := FND_API.G_RET_STS_ERROR;

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;
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

Line 1368: x_return_status := FND_API.G_RET_STS_ERROR;

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;
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;

Line 1441: IF FND_API.to_Boolean(p_init_msg_list) THEN

1437: -- Standard Start of API savepoint
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

Line 1446: x_return_status := FND_API.G_RET_STS_SUCCESS;

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;
1447:
1448: -- ---------------------------------------------------------------------
1449: -- Api body
1450: -- ---------------------------------------------------------------------

Line 1481: IF x_return_status <> FND_API.G_RET_STS_SUCCESS THEN

1477: ,x_msg_data => x_msg_data);
1478: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'l_event_id = ' || l_event_id);
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;

Line 1485: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;

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...');
1489:

Line 1528: WHEN FND_API.G_EXC_ERROR THEN

1524:
1525: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, l_api_name || ' - END');
1526:
1527: EXCEPTION
1528: WHEN FND_API.G_EXC_ERROR THEN
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;

Line 1530: x_return_status := FND_API.G_RET_STS_ERROR;

1526:
1527: EXCEPTION
1528: WHEN FND_API.G_EXC_ERROR THEN
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);

Line 1536: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN

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;
1538: x_return_status := FND_API.G_RET_STS_ERROR;
1539: x_msg_count := l_msg_count;
1540: x_msg_data := l_msg_data;

Line 1538: x_return_status := FND_API.G_RET_STS_ERROR;

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;
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);

Line 1546: x_return_status := FND_API.G_RET_STS_ERROR;

1542: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
1543:
1544: WHEN OTHERS THEN
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);

Line 1614: RAISE FND_API.G_EXC_ERROR;

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:
1618: /*=========================================================================

Line 1681: RAISE FND_API.G_EXC_ERROR;

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:');
1685: for n in 1..l_num_segments loop

Line 1718: RAISE FND_API.G_EXC_ERROR;

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);
1722: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, l_api_name || ' - END');

Line 1729: RAISE FND_API.G_EXC_ERROR;

1725:
1726: exception
1727: when others then
1728: logMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'failed to create new code combination');
1729: RAISE FND_API.G_EXC_ERROR;
1730: end swap_code_combination;
1731:
1732:
1733: /*=========================================================================

Line 1798: RAISE FND_API.G_EXC_ERROR;

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);
1802:

Line 1814: RAISE FND_API.G_EXC_ERROR;

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);
1818:

Line 2559: RAISE FND_API.G_EXC_ERROR;

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;
2563:

Line 3128: IF FND_API.to_Boolean( p_init_msg_list ) THEN

3124: l_api_name := 'validateAccounting1';
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

Line 3133: x_return_status := FND_API.G_RET_STS_SUCCESS;

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;
3134:
3135: l_dist_percent_rec_orig := 0;
3136: l_dist_percent_rec_bill := 0;
3137: l_dist_percent_clear_orig := 0;

Line 3263: RAISE FND_API.G_EXC_ERROR;

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:
3267:

Line 3279: RAISE FND_API.G_EXC_ERROR;

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
3283: -- Origination must be the same as the account code combinations for the Loans

Line 3294: RAISE FND_API.G_EXC_ERROR;

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');
3298: if j < l_loan_receivables_orig.count then

Line 3305: RAISE FND_API.G_EXC_ERROR;

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:
3309: -- F. The code combinations distribution percentages for each Loans Receivable

Line 3319: RAISE FND_API.G_EXC_ERROR;

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;
3323: l_dist_percent_rec_bill := l_dist_percent_rec_bill + l_loan_receivables_bill(j).distribution_percent;

Line 3346: RAISE FND_API.G_EXC_ERROR;

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:
3350: END IF;

Line 3367: RAISE FND_API.G_EXC_ERROR;

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;
3371: end loop;

Line 3384: RAISE FND_API.G_EXC_ERROR;

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%
3388:

Line 3395: RAISE FND_API.G_EXC_ERROR;

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:
3399: end if; -- if loan_class = 'ERS'

Line 3407: RAISE FND_API.G_EXC_ERROR;

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:
3411: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'checking origination clearing total percentages');

Line 3418: RAISE FND_API.G_EXC_ERROR;

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
3422: -- account

Line 3429: RAISE FND_API.G_EXC_ERROR;

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
3433: -- account

Line 3440: RAISE FND_API.G_EXC_ERROR;

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
3444: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'checking Interest Income count');

Line 3450: RAISE FND_API.G_EXC_ERROR;

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%
3454: for j in 1..l_int_income_bill.count loop

Line 3464: RAISE FND_API.G_EXC_ERROR;

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
3468: ,p_data => x_msg_data);

Line 3473: WHEN FND_API.G_EXC_ERROR THEN

3469:
3470: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, l_api_name || ' - END');
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);

Line 3474: x_return_status := FND_API.G_RET_STS_ERROR;

3470: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, l_api_name || ' - END');
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:

Line 3479: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN

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
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);

Line 3480: x_return_status := FND_API.G_RET_STS_ERROR;

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
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:

Line 3486: x_return_status := FND_API.G_RET_STS_ERROR;

3482: ,p_data => x_msg_data);
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:

Line 3534: x_return_status := FND_API.G_RET_STS_SUCCESS;

3530: is
3531: begin
3532:
3533: -- Initialize API return status to SUCCESS
3534: x_return_status := FND_API.G_RET_STS_SUCCESS;
3535:
3536: end validateDefaultAccounting;
3537:
3538: /*========================================================================

Line 3629: IF FND_API.to_Boolean(p_init_msg_list) THEN

3625: -- Standard Start of API savepoint
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

Line 3634: x_return_status := FND_API.G_RET_STS_SUCCESS;

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;
3635:
3636: -- ---------------------------------------------------------------------
3637: -- Api body
3638: -- ---------------------------------------------------------------------

Line 3668: RAISE FND_API.G_EXC_ERROR;

3664:
3665: if i <> 1 then
3666: if l_mfar then
3667: if l_psa_trx_type_id = -1 then
3668: RAISE FND_API.G_EXC_ERROR;
3669: end if;
3670: else
3671: if l_psa_trx_type_id <> -1 then
3672: RAISE FND_API.G_EXC_ERROR;

Line 3672: RAISE FND_API.G_EXC_ERROR;

3668: RAISE FND_API.G_EXC_ERROR;
3669: end if;
3670: else
3671: if l_psa_trx_type_id <> -1 then
3672: RAISE FND_API.G_EXC_ERROR;
3673: end if;
3674: end if;
3675: else
3676: if l_psa_trx_type_id = -1 then

Line 3727: WHEN FND_API.G_EXC_ERROR THEN

3723:
3724: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, l_api_name || ' - END');
3725:
3726: EXCEPTION
3727: WHEN FND_API.G_EXC_ERROR THEN
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;

Line 3729: x_return_status := FND_API.G_RET_STS_ERROR;

3725:
3726: EXCEPTION
3727: WHEN FND_API.G_EXC_ERROR THEN
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);

Line 3735: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN

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;
3737: x_return_status := FND_API.G_RET_STS_ERROR;
3738: x_msg_count := l_msg_count;
3739: x_msg_data := l_msg_data;

Line 3737: x_return_status := FND_API.G_RET_STS_ERROR;

3733: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
3734:
3735: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
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);

Line 3745: x_return_status := FND_API.G_RET_STS_ERROR;

3741: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
3742:
3743: WHEN OTHERS THEN
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);

Line 3840: IF FND_API.to_Boolean( p_init_msg_list ) THEN

3836: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'p_activity_type = ' || p_activity_type);
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

Line 3845: x_return_status := FND_API.G_RET_STS_SUCCESS;

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;
3846:
3847: l_disb_header_id := p_disb_header_id;
3848: l_activity := p_activity_type;
3849:

Line 3884: ,p_init_msg_list => FND_API.G_TRUE

3880:
3881: IF l_activity in ('DISBURSEMENT', 'LNS_SUBMIT_DISBURSEMENT', 'LNS_SUBMITTED_DISB_CANCEL', 'LOAN_AMOUNT_ADJUSTMENT') THEN
3882: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Calling defaultBookDistForActivity...');
3883: defaultBookDistForActivity(p_api_version => 1.0
3884: ,p_init_msg_list => FND_API.G_TRUE
3885: ,p_commit => p_commit
3886: ,p_loan_id => p_loan_id
3887: ,p_disb_header_id => l_disb_header_id
3888: ,p_loan_amount_adj_id => l_loan_amount_adj_id

Line 3897: RAISE FND_API.G_EXC_ERROR;

3893: ,x_msg_data => l_msg_data);
3894:
3895: if l_return_status <> 'S' then
3896: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Error Invoking defaultBookDistForActivity..');
3897: RAISE FND_API.G_EXC_ERROR;
3898: end if;
3899:
3900:
3901: ELSE

Line 3907: ,p_init_msg_list => FND_API.G_TRUE

3903: --break up the distribution amounts for the disbursement
3904: -- insert into the distributions table
3905: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Calling defaultDistributionsCatch...');
3906: defaultDistributionsCatch(p_api_version => 1.0
3907: ,p_init_msg_list => FND_API.G_TRUE
3908: ,p_commit => p_commit
3909: ,p_loan_id => p_loan_id
3910: ,p_disb_header_id => l_disb_header_id
3911: ,p_loan_amount_adj_id => l_loan_amount_adj_id

Line 3920: RAISE FND_API.G_EXC_ERROR;

3916: ,x_msg_count => l_msg_count
3917: ,x_msg_data => l_msg_data);
3918:
3919: if l_return_status <> 'S' then
3920: RAISE FND_API.G_EXC_ERROR;
3921: end if;
3922: END IF;
3923:
3924: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'l_distributionsCatch.count = ' || l_distributions.count);

Line 4004: IF FND_API.to_Boolean(p_commit)

4000:
4001: end if;
4002:
4003: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, l_api_name || 'p_commit is '||p_commit);
4004: IF FND_API.to_Boolean(p_commit)
4005: THEN
4006: COMMIT;
4007: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, l_api_name || 'Commited');
4008: END IF;

Line 4015: WHEN FND_API.G_EXC_ERROR THEN

4011: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, l_api_name || ' - END');
4012:
4013: EXCEPTION
4014:
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);

Line 4017: x_return_status := FND_API.G_RET_STS_ERROR;

4013: EXCEPTION
4014:
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

Line 4021: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN

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;
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);

Line 4023: x_return_status := FND_API.G_RET_STS_ERROR;

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;
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

Line 4029: x_return_status := FND_API.G_RET_STS_ERROR;

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;
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;

Line 4328: IF FND_API.to_Boolean( p_init_msg_list ) THEN

4324: logMessage(FND_LOG.level_statement, G_PKG_NAME, 'p_loan_id = ' || p_loan_id);
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

Line 4333: x_return_status := FND_API.G_RET_STS_SUCCESS;

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;
4334:
4335: -- initialize variables
4336: l_distributions_count := 0;
4337: l_distributionsCatch_count := 0;

Line 4390: if l_return_status <> FND_API.G_RET_STS_SUCCESS then

4386: ,x_msg_count => l_msg_count
4387: ,x_msg_data => l_msg_data);
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;

Line 4394: RAISE FND_API.G_EXC_ERROR;

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*/
4398: /* Commented Bug#7406404 - Defaulting the laon distributions happens only at Loan Creation time and later only updation at loan level is changed.

Line 4426: RAISE FND_API.G_EXC_ERROR;

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 );
4430:

Line 4448: RAISE FND_API.G_EXC_ERROR;

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');
4452:

Line 4458: ,p_commit => FND_API.G_FALSE

4454: -- inherit based on loan class + type ONLY
4455: logMessage(FND_LOG.level_statement, G_PKG_NAME, 'Calling defaultDistributionsCatch...');
4456: defaultDistributionsCatch(p_api_version => 1.0
4457: ,p_init_msg_list => p_init_msg_list
4458: ,p_commit => FND_API.G_FALSE
4459: ,p_loan_id => p_loan_id
4460: ,p_disb_header_id => null
4461: ,p_loan_amount_adj_id => null
4462: ,p_include_loan_receivables => 'Y'

Line 4470: RAISE FND_API.G_EXC_ERROR;

4466: ,x_msg_count => l_msg_count
4467: ,x_msg_data => l_msg_data);
4468: logMessage(FND_LOG.level_statement, G_PKG_NAME, 'l_return_status = ' || l_return_status);
4469: if l_return_status <> 'S' then
4470: RAISE FND_API.G_EXC_ERROR;
4471: end if;
4472:
4473: -- we establish the distributions for the first DISBURSEMENT only
4474: -- in order to process Budgetary Control Information

Line 4479: ,p_commit => FND_API.G_FALSE

4475: -- in SLA Transaction Line Object
4476: logMessage(FND_LOG.level_statement, G_PKG_NAME, 'Calling create_DisbursementDistribs...');
4477: create_DisbursementDistribs(p_api_version => 1.0
4478: ,p_init_msg_list => p_init_msg_list
4479: ,p_commit => FND_API.G_FALSE
4480: ,p_loan_id => p_loan_id
4481: ,p_disb_header_id => null
4482: ,p_loan_amount_adj_id => null
4483: ,p_activity_type => 'LNS_APPROVAL'

Line 4489: RAISE FND_API.G_EXC_ERROR;

4485: ,x_msg_count => l_msg_count
4486: ,x_msg_data => l_msg_data);
4487: logMessage(FND_LOG.level_statement, G_PKG_NAME, 'l_return_status = ' || l_return_status);
4488: if l_return_status <> 'S' then
4489: RAISE FND_API.G_EXC_ERROR;
4490: end if;
4491:
4492: elsif p_loan_class_code = 'ERS' then
4493:

Line 4534: RAISE FND_API.G_EXC_ERROR;

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');
4538: FND_MESSAGE.SET_TOKEN('DOC_NUM', l_trx_number);

Line 4541: RAISE FND_API.G_EXC_ERROR;

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:
4545: end loop;

Line 4617: RAISE FND_API.G_EXC_ERROR;

4613: END LOOP;
4614:
4615: close c_acc_errors;
4616:
4617: RAISE FND_API.G_EXC_ERROR;
4618: else
4619: logMessage(FND_LOG.level_statement, G_PKG_NAME, 'Online accounting SUCCESS! ');
4620: end if;
4621:

Line 4646: RAISE FND_API.G_EXC_ERROR;

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;
4650:

Line 4692: RAISE FND_API.G_EXC_ERROR;

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);
4696:

Line 4713: RAISE FND_API.G_EXC_ERROR;

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';
4717: l_distributionsCLEAR_ORIG(i).account_name := 'LOAN_CLEARING';

Line 4830: RAISE FND_API.G_EXC_ERROR;

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
4834: logMessage(FND_LOG.level_statement, G_PKG_NAME, 'NO ACCOUNTED ADJUSTMENT EXISTS');

Line 4933: ,p_init_msg_list => FND_API.G_FALSE

4929: logMessage(FND_LOG.level_statement, G_PKG_NAME, 'Billing rows - deleted ||'||SQL%ROWCOUNT||' rows');
4930:
4931: logMessage(FND_LOG.level_statement, G_PKG_NAME, 'Calling defaultDistributionsCatch...');
4932: defaultDistributionsCatch(p_api_version => 1.0
4933: ,p_init_msg_list => FND_API.G_FALSE
4934: ,p_commit => FND_API.G_FALSE
4935: ,p_loan_id => p_loan_id
4936: ,p_disb_header_id => null
4937: ,p_loan_amount_adj_id => null

Line 4934: ,p_commit => FND_API.G_FALSE

4930:
4931: logMessage(FND_LOG.level_statement, G_PKG_NAME, 'Calling defaultDistributionsCatch...');
4932: defaultDistributionsCatch(p_api_version => 1.0
4933: ,p_init_msg_list => FND_API.G_FALSE
4934: ,p_commit => FND_API.G_FALSE
4935: ,p_loan_id => p_loan_id
4936: ,p_disb_header_id => null
4937: ,p_loan_amount_adj_id => null
4938: ,p_include_loan_receivables => l_include_receivables

Line 4946: RAISE FND_API.G_EXC_ERROR;

4942: ,x_msg_count => l_msg_count
4943: ,x_msg_data => l_msg_data);
4944: logMessage(FND_LOG.level_statement, G_PKG_NAME, 'l_return_status = ' || l_return_status);
4945: if l_return_status <> 'S' then
4946: RAISE FND_API.G_EXC_ERROR;
4947: end if;
4948: END IF;
4949:
4950: End if; --loan class

Line 5004: RAISE FND_API.G_EXC_ERROR;

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
5008: COMMIT WORK;

Line 5007: IF FND_API.to_Boolean(p_commit) THEN

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
5008: COMMIT WORK;
5009: END IF;
5010:
5011: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);

Line 5016: WHEN FND_API.G_EXC_ERROR THEN

5012: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, l_api_name || ' - END');
5013:
5014: EXCEPTION
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);

Line 5018: x_return_status := FND_API.G_RET_STS_ERROR;

5014: EXCEPTION
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

Line 5022: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN

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;
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);

Line 5024: x_return_status := FND_API.G_RET_STS_ERROR;

5020: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
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

Line 5030: x_return_status := FND_API.G_RET_STS_ERROR;

5026: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
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;

Line 5161: x_return_status := FND_API.G_RET_STS_SUCCESS;

5157: l_api_name := 'onlineAccounting';
5158:
5159: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, l_api_name || ' - BEGIN');
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;

Line 5163: IF FND_API.to_Boolean( p_init_msg_list ) THEN

5159: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, l_api_name || ' - BEGIN');
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);

Line 5247: RAISE FND_API.G_EXC_ERROR;

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:
5251: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'online accounting failed ' || l_errbuf);

Line 5283: RAISE FND_API.G_EXC_ERROR;

5279: END LOOP;
5280:
5281: close c_acc_errors;
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;

Line 5292: WHEN FND_API.G_EXC_ERROR THEN

5288: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, l_api_name || ' - END');
5289:
5290: EXCEPTION
5291:
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);

Line 5294: x_return_status := FND_API.G_RET_STS_ERROR;

5290: EXCEPTION
5291:
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

Line 5298: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN

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;
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);

Line 5300: x_return_status := FND_API.G_RET_STS_ERROR;

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;
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

Line 5306: x_return_status := FND_API.G_RET_STS_ERROR;

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;
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;

Line 5392: RAISE FND_API.G_EXC_ERROR;

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:
5396: open c_loan_info(P_LOAN_ID);

Line 5417: ,p_init_msg_list => fnd_api.g_false

5413: ,p_loan_amount_adj_id => -1
5414: ,p_event_type_code => 'APPROVED'
5415: ,p_event_date => l_gl_date
5416: ,p_event_status => 'U'
5417: ,p_init_msg_list => fnd_api.g_false
5418: ,p_commit => fnd_api.g_false
5419: ,p_bc_flag => 'N'
5420: ,x_event_id => x_event_id
5421: ,x_return_status => l_return_status

Line 5418: ,p_commit => fnd_api.g_false

5414: ,p_event_type_code => 'APPROVED'
5415: ,p_event_date => l_gl_date
5416: ,p_event_status => 'U'
5417: ,p_init_msg_list => fnd_api.g_false
5418: ,p_commit => fnd_api.g_false
5419: ,p_bc_flag => 'N'
5420: ,x_event_id => x_event_id
5421: ,x_return_status => l_return_status
5422: ,x_msg_count => l_msg_count

Line 5427: IF l_return_status <> FND_API.G_RET_STS_SUCCESS THEN

5423: ,x_msg_data => l_msg_data);
5424: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'event_id = ' || x_event_id);
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'));

Line 5432: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;

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:
5436:

Line 5440: ,p_init_msg_list => FND_API.G_TRUE

5436:
5437: -- we should do online accounting in batch mode here
5438: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Calling Lns_distributions_pub.defaultDistributions...');
5439: Lns_distributions_pub.defaultDistributions(p_api_version => 1.0
5440: ,p_init_msg_list => FND_API.G_TRUE
5441: ,p_commit => FND_API.G_FALSE
5442: ,p_loan_id => P_LOAN_ID
5443: ,p_loan_class_code => l_loan_class_code
5444: ,x_return_status => l_return_status

Line 5441: ,p_commit => FND_API.G_FALSE

5437: -- we should do online accounting in batch mode here
5438: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Calling Lns_distributions_pub.defaultDistributions...');
5439: Lns_distributions_pub.defaultDistributions(p_api_version => 1.0
5440: ,p_init_msg_list => FND_API.G_TRUE
5441: ,p_commit => FND_API.G_FALSE
5442: ,p_loan_id => P_LOAN_ID
5443: ,p_loan_class_code => l_loan_class_code
5444: ,x_return_status => l_return_status
5445: ,x_msg_count => l_msg_count

Line 5449: IF l_return_status <> FND_API.G_RET_STS_SUCCESS THEN

5445: ,x_msg_count => l_msg_count
5446: ,x_msg_data => l_msg_data);
5447: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'l_return_status = ' || l_return_status);
5448:
5449: IF l_return_status <> FND_API.G_RET_STS_SUCCESS THEN
5450: -- logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Call to Lns_distributions_pub.defaultDistributions failed with status ' || l_return_status);
5451: -- fnd_file.put_line(FND_FILE.LOG, 'FAILED TO INHERIT DISTRIBUTIONS');
5452: --l_last_api_called := 'Lns_distributions_pub.defaultDistributions';
5453: RAISE FND_API.G_EXC_ERROR;

Line 5453: RAISE FND_API.G_EXC_ERROR;

5449: IF l_return_status <> FND_API.G_RET_STS_SUCCESS THEN
5450: -- logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Call to Lns_distributions_pub.defaultDistributions failed with status ' || l_return_status);
5451: -- fnd_file.put_line(FND_FILE.LOG, 'FAILED TO INHERIT DISTRIBUTIONS');
5452: --l_last_api_called := 'Lns_distributions_pub.defaultDistributions';
5453: RAISE FND_API.G_EXC_ERROR;
5454: ELSE
5455:
5456: if x_event_id is not null then
5457: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Updating lns_distributions...');

Line 5471: l_loan_header_rec.secondary_status := FND_API.G_MISS_CHAR;

5467:
5468: -- finally update the loan header
5469: l_loan_header_rec.loan_id := P_LOAN_ID;
5470: l_loan_header_rec.loan_status := 'ACTIVE';
5471: l_loan_header_rec.secondary_status := FND_API.G_MISS_CHAR;
5472: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Before call to LNS_LOAN_HEADER_PUB.update_loan');
5473: LNS_LOAN_HEADER_PUB.update_loan(p_init_msg_list => FND_API.G_FALSE
5474: ,p_loan_header_rec => l_loan_header_rec
5475: ,p_object_version_number => l_object_version_number

Line 5473: LNS_LOAN_HEADER_PUB.update_loan(p_init_msg_list => FND_API.G_FALSE

5469: l_loan_header_rec.loan_id := P_LOAN_ID;
5470: l_loan_header_rec.loan_status := 'ACTIVE';
5471: l_loan_header_rec.secondary_status := FND_API.G_MISS_CHAR;
5472: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Before call to LNS_LOAN_HEADER_PUB.update_loan');
5473: LNS_LOAN_HEADER_PUB.update_loan(p_init_msg_list => FND_API.G_FALSE
5474: ,p_loan_header_rec => l_loan_header_rec
5475: ,p_object_version_number => l_object_version_number
5476: ,x_return_status => l_return_status
5477: ,x_msg_count => l_msg_count

Line 5484: IF l_return_status <> FND_API.G_RET_STS_SUCCESS THEN

5480: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'l_msg_data = ' || l_msg_data);
5481:
5482: END IF;
5483:
5484: IF l_return_status <> FND_API.G_RET_STS_SUCCESS THEN
5485: RAISE FND_API.G_EXC_ERROR;
5486: else
5487: -- now check if 0th installment needs billing
5488:

Line 5485: RAISE FND_API.G_EXC_ERROR;

5481:
5482: END IF;
5483:
5484: IF l_return_status <> FND_API.G_RET_STS_SUCCESS THEN
5485: RAISE FND_API.G_EXC_ERROR;
5486: else
5487: -- now check if 0th installment needs billing
5488:
5489: /* check to start billing for 0-th installment */

Line 5531: l_return_status := FND_API.G_RET_STS_UNEXP_ERROR;

5527: null,
5528: null);
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;

Line 5535: RAISE FND_API.G_EXC_ERROR;

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);
5538: end if;
5539:

Line 5555: RETCODE := FND_API.G_RET_STS_ERROR;

5551: WHEN others THEN
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!');

Line 5600: IF FND_API.to_Boolean( p_init_msg_list ) THEN

5596: l_api_name := 'createDistrForImport';
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

Line 5605: x_return_status := FND_API.G_RET_STS_SUCCESS;

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;
5606:
5607: /* deleting any existing accounting rows */
5608: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, l_api_name || ' deleting any existing accounting rows');
5609: delete from lns_distributions

Line 5627: RAISE FND_API.G_EXC_ERROR;

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
5631: might be in GL CLosed period

Line 5645: ,p_init_msg_list => fnd_api.g_false

5641: ,p_loan_amount_adj_id => -1
5642: ,p_event_type_code => 'APPROVED'
5643: ,p_event_date => l_gl_date
5644: ,p_event_status => 'U'
5645: ,p_init_msg_list => fnd_api.g_false
5646: ,p_commit => fnd_api.g_false
5647: ,p_bc_flag => 'N'
5648: ,x_event_id => l_event_id
5649: ,x_return_status => l_return_status

Line 5646: ,p_commit => fnd_api.g_false

5642: ,p_event_type_code => 'APPROVED'
5643: ,p_event_date => l_gl_date
5644: ,p_event_status => 'U'
5645: ,p_init_msg_list => fnd_api.g_false
5646: ,p_commit => fnd_api.g_false
5647: ,p_bc_flag => 'N'
5648: ,x_event_id => l_event_id
5649: ,x_return_status => l_return_status
5650: ,x_msg_count => l_msg_count

Line 5655: IF l_return_status <> FND_API.G_RET_STS_SUCCESS THEN

5651: ,x_msg_data => l_msg_data);
5652: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'l_event_id = ' || l_event_id);
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'));

Line 5660: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;

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
5664: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Updating lns_distributions...');

Line 5677: IF FND_API.to_Boolean(p_commit)

5673: end if;
5674:
5675: */
5676:
5677: IF FND_API.to_Boolean(p_commit)
5678: THEN
5679: COMMIT WORK;
5680: END IF;
5681:

Line 5688: WHEN FND_API.G_EXC_ERROR THEN

5684: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, l_api_name || ' - END');
5685:
5686: EXCEPTION
5687:
5688: WHEN FND_API.G_EXC_ERROR THEN
5689: x_return_status := FND_API.G_RET_STS_ERROR;
5690: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
5691: ROLLBACK TO createDistrForImport;
5692:

Line 5689: x_return_status := FND_API.G_RET_STS_ERROR;

5685:
5686: EXCEPTION
5687:
5688: WHEN FND_API.G_EXC_ERROR THEN
5689: x_return_status := FND_API.G_RET_STS_ERROR;
5690: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
5691: ROLLBACK TO createDistrForImport;
5692:
5693: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN

Line 5693: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN

5689: x_return_status := FND_API.G_RET_STS_ERROR;
5690: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
5691: ROLLBACK TO createDistrForImport;
5692:
5693: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
5694: x_return_status := FND_API.G_RET_STS_ERROR;
5695: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
5696: ROLLBACK TO createDistrForImport;
5697:

Line 5694: x_return_status := FND_API.G_RET_STS_ERROR;

5690: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
5691: ROLLBACK TO createDistrForImport;
5692:
5693: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
5694: x_return_status := FND_API.G_RET_STS_ERROR;
5695: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
5696: ROLLBACK TO createDistrForImport;
5697:
5698: WHEN OTHERS THEN

Line 5699: x_return_status := FND_API.G_RET_STS_ERROR;

5695: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
5696: ROLLBACK TO createDistrForImport;
5697:
5698: WHEN OTHERS THEN
5699: x_return_status := FND_API.G_RET_STS_ERROR;
5700: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
5701: ROLLBACK TO createDistrForImport;
5702:
5703: end;

Line 5767: IF FND_API.to_Boolean( p_init_msg_list ) THEN

5763: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'p_loan_amount_adj_id = ' || p_loan_amount_adj_id);
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

Line 5772: x_return_status := FND_API.G_RET_STS_SUCCESS;

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;
5773:
5774: -- We can't default distributions without valid loan adjustment
5775: IF p_loan_amount_adj_id IS NULL THEN
5776: -- Retrieve the Pending Loan Amount Adjustment Id of the loan

Line 5788: if l_return_status <> FND_API.G_RET_STS_SUCCESS then

5784: ,p_col_id => p_loan_id
5785: ,p_col_name => 'LOAN_ID'
5786: ,p_table_name => 'LNS_LOAN_HEADERS');
5787:
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;

Line 5793: RAISE FND_API.G_EXC_ERROR;

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);
5797: FETCH c_loan_adj INTO l_loan_amount_adj_id, l_adj_status, l_adj_amount;

Line 5812: RAISE FND_API.G_EXC_ERROR;

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:
5816: l_loan_id := p_loan_id;

Line 5830: if l_return_status <> FND_API.G_RET_STS_SUCCESS then

5826: ,p_col_id => p_loan_amount_adj_id
5827: ,p_col_name => 'LOAN_AMOUNT_ADJ_ID'
5828: ,p_table_name => 'LNS_LOAN_AMOUNT_ADJS');
5829:
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;

Line 5835: RAISE FND_API.G_EXC_ERROR;

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:
5839: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'fetching l_loan_adj details');

Line 5860: RAISE FND_API.G_EXC_ERROR;

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*/
5864: logMessage(FND_LOG.level_statement, G_PKG_NAME, 'Deleting any existing adjustment accounting rows for '||l_loan_id||'-'||l_loan_amount_adj_id);

Line 5890: RAISE FND_API.G_EXC_ERROR;

5886: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, l_api_name || ' The return status is '||l_return_status);
5887:
5888: IF l_return_status <> 'S' THEN
5889: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, l_api_name || ' CreationDisbursementDistribs failed with error '||l_msg_data);
5890: RAISE FND_API.G_EXC_ERROR;
5891: END IF;
5892:
5893:
5894: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, l_api_name || ' - END');

Line 5898: WHEN FND_API.G_EXC_ERROR THEN

5894: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, l_api_name || ' - END');
5895:
5896: EXCEPTION
5897:
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);

Line 5900: x_return_status := FND_API.G_RET_STS_ERROR;

5896: EXCEPTION
5897:
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

Line 5904: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN

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;
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);

Line 5906: x_return_status := FND_API.G_RET_STS_ERROR;

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;
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

Line 5912: x_return_status := FND_API.G_RET_STS_ERROR;

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;
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:

Line 6042: IF FND_API.to_Boolean( p_init_msg_list ) THEN

6038: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'p_loan_id = ' || p_loan_id);
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

Line 6047: x_return_status := FND_API.G_RET_STS_SUCCESS;

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;
6048:
6049: -- We can't check funds without valid loan adjustment
6050: IF p_loan_amount_adj_id IS NULL THEN
6051: -- Retrieve the Pending Loan Amount Adjustment Id of the loan

Line 6063: if l_return_status <> FND_API.G_RET_STS_SUCCESS then

6059: ,p_col_id => p_loan_id
6060: ,p_col_name => 'LOAN_ID'
6061: ,p_table_name => 'LNS_LOAN_HEADERS');
6062:
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;

Line 6068: RAISE FND_API.G_EXC_ERROR;

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);
6072: FETCH c_loan_adj INTO l_loan_amount_adj_id, l_adj_status, l_adj_amount;

Line 6084: RAISE FND_API.G_EXC_ERROR;

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:
6088: l_loan_id := p_loan_id;

Line 6102: if l_return_status <> FND_API.G_RET_STS_SUCCESS then

6098: ,p_col_id => p_loan_amount_adj_id
6099: ,p_col_name => 'LOAN_AMOUNT_ADJ_ID'
6100: ,p_table_name => 'LNS_LOAN_AMOUNT_ADJS');
6101:
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;

Line 6107: RAISE FND_API.G_EXC_ERROR;

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:
6111: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'fetching l_loan_adj details');

Line 6127: RAISE FND_API.G_EXC_ERROR;

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;
6131:

Line 6166: ,p_init_msg_list => fnd_api.g_false

6162: ,p_loan_amount_adj_id => l_loan_amount_adj_id
6163: ,p_event_type_code => l_event_type
6164: ,p_event_date => l_gl_date
6165: ,p_event_status => 'U'
6166: ,p_init_msg_list => fnd_api.g_false
6167: ,p_commit => fnd_api.g_false
6168: ,p_bc_flag => 'Y'
6169: ,x_event_id => l_event_id
6170: ,x_return_status => x_return_status

Line 6167: ,p_commit => fnd_api.g_false

6163: ,p_event_type_code => l_event_type
6164: ,p_event_date => l_gl_date
6165: ,p_event_status => 'U'
6166: ,p_init_msg_list => fnd_api.g_false
6167: ,p_commit => fnd_api.g_false
6168: ,p_bc_flag => 'Y'
6169: ,x_event_id => l_event_id
6170: ,x_return_status => x_return_status
6171: ,x_msg_count => x_msg_count

Line 6176: IF x_return_status <> FND_API.G_RET_STS_SUCCESS THEN

6172: ,x_msg_data => x_msg_data);
6173: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'x_return_status = ' || x_return_status);
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;

Line 6180: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;

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
6184: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'stamping eventID on lns_distributions');

Line 6213: ,p_init_msg_list => FND_API.G_FALSE

6209: values (l_event_id, 'FAIL');
6210:
6211: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Calling PSA_BC_XLA_PUB.Budgetary_Control ' || l_event_id);
6212: PSA_BC_XLA_PUB.Budgetary_Control(p_api_version => 1.0
6213: ,p_init_msg_list => FND_API.G_FALSE
6214: ,x_return_status => l_return_status
6215: ,x_msg_count => l_msg_count
6216: ,x_msg_data => l_msg_data
6217: ,p_application_id => 206

Line 6232: l_return_status := FND_API.G_RET_STS_ERROR;

6228: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, l_api_name || 'l_packet_id = ' || l_packet_id);
6229:
6230: if (l_return_status <> 'S' ) then
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'));

Line 6237: RAISE FND_API.G_EXC_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);
6241:

Line 6262: RAISE FND_API.G_EXC_ERROR;

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);
6266: FND_MSG_PUB.ADD;

Line 6268: RAISE FND_API.G_EXC_ERROR;

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: */
6272: -- For FundsReserve, we update the fundsCheckDate from UI

Line 6283: ,P_INIT_MSG_LIST => FND_API.G_FALSE

6279: l_loan_header_rec.FUNDS_CHECK_DATE := sysdate;
6280: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, l_api_name || 'updating loan');
6281: LNS_LOAN_HEADER_PUB.UPDATE_LOAN(P_OBJECT_VERSION_NUMBER => l_version
6282: ,P_LOAN_HEADER_REC => l_loan_header_rec
6283: ,P_INIT_MSG_LIST => FND_API.G_FALSE
6284: ,X_RETURN_STATUS => l_return_status
6285: ,X_MSG_COUNT => l_msg_count
6286: ,X_MSG_DATA => l_msg_data);
6287: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'update loan status = ' || l_return_status);

Line 6293: RAISE FND_API.G_EXC_ERROR;

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:
6297: x_budgetary_status_code := l_status_code;

Line 6305: IF (l_return_status = 'S' AND FND_API.to_Boolean(p_commit))

6301:
6302: end if; -- l_funds_reserved_flag
6303:
6304:
6305: IF (l_return_status = 'S' AND FND_API.to_Boolean(p_commit))
6306: THEN
6307: COMMIT WORK;
6308: END IF;
6309:

Line 6316: WHEN FND_API.G_EXC_ERROR THEN

6312: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, l_api_name || ' - END');
6313:
6314: EXCEPTION
6315:
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);

Line 6318: x_return_status := FND_API.G_RET_STS_ERROR;

6314: EXCEPTION
6315:
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

Line 6322: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN

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;
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);

Line 6324: x_return_status := FND_API.G_RET_STS_ERROR;

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;
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

Line 6330: x_return_status := FND_API.G_RET_STS_ERROR;

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;
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;

Line 6385: IF FND_API.to_Boolean( p_init_msg_list ) THEN

6381: l_api_name := 'validateAddRecAccounting';
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

Line 6390: x_return_status := FND_API.G_RET_STS_SUCCESS;

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;
6391:
6392: l_dist_percent_rec_bill := 0;
6393:
6394: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Calling LNS_DISTRIBUTIONS_PUB.getDistributions 1...');

Line 6431: RAISE FND_API.G_EXC_ERROR;

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
6435: ,p_data => x_msg_data);

Line 6440: WHEN FND_API.G_EXC_ERROR THEN

6436:
6437: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, l_api_name || ' - END');
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);

Line 6441: x_return_status := FND_API.G_RET_STS_ERROR;

6437: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, l_api_name || ' - END');
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:

Line 6446: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN

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
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);

Line 6447: x_return_status := FND_API.G_RET_STS_ERROR;

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
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:

Line 6453: x_return_status := FND_API.G_RET_STS_ERROR;

6449: ,p_data => x_msg_data);
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:

Line 6727: IF FND_API.to_Boolean( p_init_msg_list ) THEN

6723: l_api_name := 'createDistrForAddRec';
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

Line 6732: x_return_status := FND_API.G_RET_STS_SUCCESS;

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;
6733:
6734: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Input p_loan_id = ' || p_loan_id);
6735: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Input p_loan_line_id = ' || p_loan_line_id);
6736:

Line 6742: RAISE FND_API.G_EXC_ERROR;

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:
6746: if P_LOAN_LINE_ID is null then

Line 6751: RAISE FND_API.G_EXC_ERROR;

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:
6755: logMessage(FND_LOG.level_statement, G_PKG_NAME, 'Starting ERS INHERITANCE');

Line 6786: RAISE FND_API.G_EXC_ERROR;

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');
6790: FND_MESSAGE.SET_TOKEN('DOC_NUM', l_trx_number);

Line 6793: RAISE FND_API.G_EXC_ERROR;

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:
6797: end loop;

Line 6869: RAISE FND_API.G_EXC_ERROR;

6865: END LOOP;
6866:
6867: close c_acc_errors;
6868:
6869: RAISE FND_API.G_EXC_ERROR;
6870: else
6871: logMessage(FND_LOG.level_statement, G_PKG_NAME, 'Online accounting SUCCESS! ');
6872: end if;
6873:

Line 6898: RAISE FND_API.G_EXC_ERROR;

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;
6902:

Line 6942: RAISE FND_API.G_EXC_ERROR;

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
6946: i := 0;

Line 7124: RAISE FND_API.G_EXC_ERROR;

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
7128: logMessage(FND_LOG.level_statement, G_PKG_NAME, 'NO ACCOUNTED ADJUSTMENT EXISTS');

Line 7196: RAISE FND_API.G_EXC_ERROR;

7192: ,x_msg_data => l_msg_data);
7193:
7194: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, l_api_name || 'Accounting status is ' || l_return_status);
7195: if l_return_status <> 'S' then
7196: RAISE FND_API.G_EXC_ERROR;
7197: end if;
7198:
7199: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'l_gl_date = ' || l_gl_date);
7200:

Line 7209: ,p_init_msg_list => fnd_api.g_false

7205: ,p_loan_line_id => p_loan_line_id
7206: ,p_event_type_code => 'ERS_LOAN_ADD_REC_APPROVED'
7207: ,p_event_date => l_gl_date
7208: ,p_event_status => 'U'
7209: ,p_init_msg_list => fnd_api.g_false
7210: ,p_commit => fnd_api.g_false
7211: ,p_bc_flag => 'N'
7212: ,x_event_id => l_event_id
7213: ,x_return_status => l_return_status

Line 7210: ,p_commit => fnd_api.g_false

7206: ,p_event_type_code => 'ERS_LOAN_ADD_REC_APPROVED'
7207: ,p_event_date => l_gl_date
7208: ,p_event_status => 'U'
7209: ,p_init_msg_list => fnd_api.g_false
7210: ,p_commit => fnd_api.g_false
7211: ,p_bc_flag => 'N'
7212: ,x_event_id => l_event_id
7213: ,x_return_status => l_return_status
7214: ,x_msg_count => l_msg_count

Line 7219: IF l_return_status <> FND_API.G_RET_STS_SUCCESS THEN

7215: ,x_msg_data => l_msg_data);
7216: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'l_event_id = ' || l_event_id);
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'));

Line 7224: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;

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
7228: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Updating lns_distributions...');

Line 7239: IF FND_API.to_Boolean(p_commit)

7235: and activity = 'ERS_ADD_REC';
7236: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Done');
7237: end if;
7238:
7239: IF FND_API.to_Boolean(p_commit)
7240: THEN
7241: COMMIT WORK;
7242: END IF;
7243:

Line 7250: WHEN FND_API.G_EXC_ERROR THEN

7246: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, l_api_name || ' - END');
7247:
7248: EXCEPTION
7249:
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;

Line 7251: x_return_status := FND_API.G_RET_STS_ERROR;

7247:
7248: EXCEPTION
7249:
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);

Line 7259: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN

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;
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;

Line 7260: x_return_status := FND_API.G_RET_STS_ERROR;

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;
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);

Line 7269: x_return_status := FND_API.G_RET_STS_ERROR;

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;
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);

Line 7406: IF FND_API.to_Boolean( p_init_msg_list ) THEN

7402: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, l_api_name || ' - BEGIN');
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

Line 7411: x_return_status := FND_API.G_RET_STS_SUCCESS;

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;
7412:
7413: -- initialize variables
7414:
7415: l_Cnt := 0;

Line 7435: IF l_return_status <> FND_API.G_RET_STS_SUCCESS THEN

7431: ,p_col_id => p_loan_id
7432: ,p_col_name => 'LOAN_ID'
7433: ,p_table_name => 'LNS_LOAN_HEADERS');
7434:
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;

Line 7440: RAISE FND_API.G_EXC_ERROR;

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);
7444: FETCH c_loan_info INTO l_loan_class, l_requested_amount, l_funded_amount, l_subsidy_rate;

Line 7585: IF FND_API.to_Boolean(p_commit)

7581: do_insert_distributions(l_distributions, p_loan_id);
7582:
7583:
7584: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, l_api_name || 'p_commit is '||p_commit);
7585: IF FND_API.to_Boolean(p_commit)
7586: THEN
7587: COMMIT;
7588: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, l_api_name || 'Commited');
7589: END IF;

Line 7596: WHEN FND_API.G_EXC_ERROR THEN

7592: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, l_api_name || ' - END');
7593:
7594: EXCEPTION
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);

Line 7598: x_return_status := FND_API.G_RET_STS_ERROR;

7594: EXCEPTION
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

Line 7602: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN

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;
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);

Line 7604: x_return_status := FND_API.G_RET_STS_ERROR;

7600: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
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

Line 7610: x_return_status := FND_API.G_RET_STS_ERROR;

7606: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
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;

Line 7689: IF FND_API.to_Boolean( p_init_msg_list ) THEN

7685: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'p_disb_header_id ' || p_disb_header_id);
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

Line 7694: x_return_status := FND_API.G_RET_STS_SUCCESS;

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;
7695:
7696:
7697: IF p_activity = 'LNS_SUBMITTED_DISB_CANCEL' THEN
7698: -- first complete accounting for any unprocessed events / documents for the loan transaction

Line 7701: ,p_init_msg_list => fnd_api.g_false

7697: IF p_activity = 'LNS_SUBMITTED_DISB_CANCEL' THEN
7698: -- first complete accounting for any unprocessed events / documents for the loan transaction
7699: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Calling lns_distributions_pub.onlineAccounting...');
7700: lns_distributions_pub.onlineAccounting(p_loan_id => p_loan_id
7701: ,p_init_msg_list => fnd_api.g_false
7702: ,p_accounting_mode => 'F'
7703: ,p_transfer_flag => 'Y'
7704: ,p_offline_flag => 'N'
7705: ,p_gl_posting_flag => 'N'

Line 7711: RAISE FND_API.G_EXC_ERROR;

7707: ,x_msg_count => l_msg_count
7708: ,x_msg_data => l_msg_data);
7709: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'l_return_status = ' || l_return_status);
7710: if l_return_status <> 'S' then
7711: RAISE FND_API.G_EXC_ERROR;
7712: end if;
7713: END IF;
7714:
7715: /*

Line 7729: p_init_msg_list => FND_API.G_FALSE,

7725: -- create disbursement distribution records in lns_distributions for Disbursement Submission
7726: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Calling create_DisbursementDistribs...');
7727: LNS_DISTRIBUTIONS_PUB.create_DisbursementDistribs(
7728: p_api_version => 1.0,
7729: p_init_msg_list => FND_API.G_FALSE,
7730: p_commit => FND_API.G_FALSE,
7731: p_loan_id => p_loan_id,
7732: p_disb_header_id => p_disb_header_id,
7733: p_activity_type => p_activity,

Line 7730: p_commit => FND_API.G_FALSE,

7726: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Calling create_DisbursementDistribs...');
7727: LNS_DISTRIBUTIONS_PUB.create_DisbursementDistribs(
7728: p_api_version => 1.0,
7729: p_init_msg_list => FND_API.G_FALSE,
7730: p_commit => FND_API.G_FALSE,
7731: p_loan_id => p_loan_id,
7732: p_disb_header_id => p_disb_header_id,
7733: p_activity_type => p_activity,
7734: x_return_status => l_return_status,

Line 7741: RAISE FND_API.G_EXC_ERROR;

7737:
7738: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Return status: ' || l_return_status);
7739: IF l_return_status <> 'S' THEN
7740: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Call to LNS_DISTRIBUTIONS_PUB.create_DisbursementDistribs for Disb Submit failed');
7741: RAISE FND_API.G_EXC_ERROR;
7742: END IF;
7743:
7744: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'federal enabled');
7745: open c_budget_req(p_loan_id);

Line 7772: ,p_init_msg_list => fnd_api.g_false

7768: ,p_loan_amount_adj_id => -1
7769: ,p_event_type_code => l_event_type_code
7770: ,p_event_date => l_PAYMENT_REQUEST_DATE
7771: ,p_event_status => 'U'
7772: ,p_init_msg_list => fnd_api.g_false
7773: ,p_commit => fnd_api.g_false
7774: ,p_bc_flag => 'Y'
7775: ,x_event_id => l_event_id
7776: ,x_return_status => l_return_status

Line 7773: ,p_commit => fnd_api.g_false

7769: ,p_event_type_code => l_event_type_code
7770: ,p_event_date => l_PAYMENT_REQUEST_DATE
7771: ,p_event_status => 'U'
7772: ,p_init_msg_list => fnd_api.g_false
7773: ,p_commit => fnd_api.g_false
7774: ,p_bc_flag => 'Y'
7775: ,x_event_id => l_event_id
7776: ,x_return_status => l_return_status
7777: ,x_msg_count => l_msg_count

Line 7782: IF x_return_status <> FND_API.G_RET_STS_SUCCESS THEN

7778: ,x_msg_data => l_msg_data);
7779: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'l_return_status = ' || l_return_status);
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;

Line 7786: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;

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');
7790: update lns_distributions

Line 7811: ,p_init_msg_list => FND_API.G_FALSE

7807:
7808: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Calling PSA_BC_XLA_PUB.Budgetary_Control ' || l_event_id);
7809: -- always pass P_BC_MODE = reserve as per shaniqua williams
7810: PSA_BC_XLA_PUB.Budgetary_Control(p_api_version => 1.0
7811: ,p_init_msg_list => FND_API.G_FALSE
7812: ,x_return_status => l_return_status
7813: ,x_msg_count => l_msg_count
7814: ,x_msg_data => l_msg_data
7815: ,p_application_id => 206

Line 7830: x_return_status := FND_API.G_RET_STS_ERROR;

7826:
7827: -- we want to commit ONLY in the case of SUCCESS or ADVISORY
7828: if (l_return_status <> 'S') then
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'));

Line 7835: RAISE FND_API.G_EXC_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
7839: null;

Line 7849: IF FND_API.to_Boolean(p_commit)

7845:
7846: end if;
7847:
7848: x_return_status := l_return_status;
7849: IF FND_API.to_Boolean(p_commit)
7850: THEN
7851: COMMIT WORK;
7852: END IF;
7853:

Line 7858: WHEN FND_API.G_EXC_ERROR THEN

7854: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, l_api_name || ' - END');
7855:
7856: EXCEPTION
7857:
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);

Line 7860: x_return_status := FND_API.G_RET_STS_ERROR;

7856: EXCEPTION
7857:
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

Line 7864: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN

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;
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);

Line 7866: x_return_status := FND_API.G_RET_STS_ERROR;

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;
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

Line 7872: x_return_status := FND_API.G_RET_STS_ERROR;

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;
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;

Line 8519: IF FND_API.to_Boolean( p_init_msg_list ) THEN

8515:
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

Line 8524: x_return_status := FND_API.G_RET_STS_SUCCESS;

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;
8525:
8526: --l_activity := 'INTEREST_ACCRUAL';
8527: l_activity := p_activity_type;
8528:

Line 8634: RAISE FND_API.G_EXC_ERROR;

8630:
8631: CLOSE c_get_bill_int_distrbs;
8632:
8633: if l_return_status <> 'S' then
8634: RAISE FND_API.G_EXC_ERROR;
8635: end if;
8636:
8637: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'l_distributionsCatch.count = ' || l_distributions.count);
8638: for j in 1..l_distributions.count loop

Line 8663: RAISE FND_API.G_EXC_ERROR;

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
8666:
8667: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, l_api_name || 'p_commit is '||p_commit);

Line 8668: IF FND_API.to_Boolean(p_commit)

8664:
8665: END IF; -- IF l_exists == 0
8666:
8667: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, l_api_name || 'p_commit is '||p_commit);
8668: IF FND_API.to_Boolean(p_commit)
8669: THEN
8670: COMMIT;
8671: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, l_api_name || 'Commited');
8672: END IF;

Line 8679: WHEN FND_API.G_EXC_ERROR THEN

8675: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, l_api_name || ' - END');
8676:
8677: EXCEPTION
8678:
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);

Line 8681: x_return_status := FND_API.G_RET_STS_ERROR;

8677: EXCEPTION
8678:
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

Line 8685: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN

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;
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);

Line 8687: x_return_status := FND_API.G_RET_STS_ERROR;

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;
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

Line 8693: x_return_status := FND_API.G_RET_STS_ERROR;

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;
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;

Line 9145: IF FND_API.to_Boolean( p_init_msg_list ) THEN

9141:
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

Line 9150: x_return_status := FND_API.G_RET_STS_SUCCESS;

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;
9151:
9152:
9153: l_new_line := '
9154: ';

Line 9194: RAISE FND_API.G_EXC_ERROR;

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:
9197: IF (l_last_accrued_date IS NOT NULL AND p_accrual_date <= l_last_accrued_date) THEN
9198:

Line 9205: RAISE FND_API.G_EXC_ERROR;

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:
9208:
9209: -- 0. Calculate the accrued interest

Line 9222: RAISE FND_API.G_EXC_ERROR;

9218: ,x_accrued_interest => l_accrued_int_amount
9219: ,x_statement => x_statement_xml);
9220: EXCEPTION
9221: WHEN OTHERS THEN
9222: RAISE FND_API.G_EXC_ERROR;
9223: END;
9224:
9225: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'l_accrued_int_amount = ' || l_accrued_int_amount);
9226: -- logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'l_accrued_int_detail_str = ' || l_accrued_int_detail_str);

Line 9251: RAISE FND_API.G_EXC_ERROR;

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);
9254: LNS_XLA_EVENTS.delete_event(p_loan_id => P_loan_id
9255: ,p_disb_header_id => -1

Line 9269: RAISE FND_API.G_EXC_ERROR;

9265: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'l_return_status = ' || l_return_status);
9266: IF l_return_status <> 'S' THEN
9267: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Deleting event_id failed');
9268:
9269: RAISE FND_API.G_EXC_ERROR;
9270: END IF;
9271:
9272: END IF;
9273:

Line 9310: RAISE FND_API.G_EXC_ERROR;

9306: ,x_msg_data => l_msg_data);
9307:
9308: logMessage(FND_LOG.level_statement, G_PKG_NAME, 'l_return_status = ' || l_return_status);
9309: if l_return_status <> 'S' then
9310: RAISE FND_API.G_EXC_ERROR;
9311: end if;
9312:
9313:
9314: -- 2. Generate an Accrual Event

Line 9328: ,p_init_msg_list => fnd_api.g_false

9324: ,p_loan_amount_adj_id => -1
9325: ,p_event_type_code => 'LOAN_ACCRUAL'
9326: ,p_event_date => p_accrual_date
9327: ,p_event_status => 'U'
9328: ,p_init_msg_list => fnd_api.g_false
9329: ,p_commit => fnd_api.g_false
9330: ,p_bc_flag => 'N'
9331: ,x_event_id => l_event_id
9332: ,x_return_status => l_return_status

Line 9329: ,p_commit => fnd_api.g_false

9325: ,p_event_type_code => 'LOAN_ACCRUAL'
9326: ,p_event_date => p_accrual_date
9327: ,p_event_status => 'U'
9328: ,p_init_msg_list => fnd_api.g_false
9329: ,p_commit => fnd_api.g_false
9330: ,p_bc_flag => 'N'
9331: ,x_event_id => l_event_id
9332: ,x_return_status => l_return_status
9333: ,x_msg_count => l_msg_count

Line 9339: IF l_return_status <> FND_API.G_RET_STS_SUCCESS THEN

9335:
9336: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'x_return_status = ' || l_return_status);
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;

Line 9343: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;

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
9347: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'stamping eventID on lns_distributions');

Line 9440: IF FND_API.to_Boolean(p_commit)

9436: --DBMS_LOB.write(X_STATEMENT_XML, length(l_statement), 1, l_statement);
9437:
9438:
9439: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, l_api_name || 'p_commit is '||p_commit);
9440: IF FND_API.to_Boolean(p_commit)
9441: THEN
9442: COMMIT;
9443: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, l_api_name || 'Commited');
9444: END IF;

Line 9453: x_return_status := FND_API.G_RET_STS_ERROR;

9449: EXCEPTION
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 */

Line 9466: WHEN FND_API.G_EXC_ERROR THEN

9462: ,P_RESULT => 'W'
9463: ,P_ERR_COUNT => x_msg_count
9464: ,X_STATEMENT_XML => X_STATEMENT_XML);
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);

Line 9468: x_return_status := FND_API.G_RET_STS_ERROR;

9464: ,X_STATEMENT_XML => X_STATEMENT_XML);
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 */

Line 9481: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN

9477: ,P_RESULT => 'E'
9478: ,P_ERR_COUNT => x_msg_count
9479: ,X_STATEMENT_XML => X_STATEMENT_XML);
9480:
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);

Line 9483: x_return_status := FND_API.G_RET_STS_ERROR;

9479: ,X_STATEMENT_XML => X_STATEMENT_XML);
9480:
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';

Line 9499: x_return_status := FND_API.G_RET_STS_ERROR;

9495: ,X_STATEMENT_XML => X_STATEMENT_XML);
9496:
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';

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

9658: SAVEPOINT ACCRUE_LOANS_INTEREST_PVT;
9659: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Savepoint is established');
9660:
9661: -- Standard call to check for call compatibility
9662: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version, l_api_name, G_PKG_NAME) THEN
9663: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
9664: END IF;
9665:
9666: -- Initialize message list if p_init_msg_list is set to TRUE

Line 9663: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;

9659: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Savepoint is established');
9660:
9661: -- Standard call to check for call compatibility
9662: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version, l_api_name, G_PKG_NAME) THEN
9663: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
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

Line 9667: IF FND_API.To_Boolean(p_init_msg_list) THEN

9663: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
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

Line 9672: l_return_status := FND_API.G_RET_STS_SUCCESS;

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;
9673: g_passed_loan_cnt := 0;
9674: g_failed_loan_cnt := 0;
9675:
9676: -- START OF BODY OF API

Line 9711: RAISE FND_API.G_EXC_ERROR;

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:
9715:

Line 9753: RAISE FND_API.G_EXC_ERROR;

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
9757:

Line 9771: RAISE FND_API.G_EXC_ERROR;

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;
9775:

Line 9801: RAISE FND_API.G_EXC_ERROR;

9797: ,P_ERR_COUNT => x_msg_count
9798: ,X_STATEMENT_XML => l_error_statements_xml);
9799:
9800: dbms_lob.Append(g_cp_statements, l_error_statements_xml);
9801: RAISE FND_API.G_EXC_ERROR;
9802: END IF;
9803: END IF;
9804:
9805:

Line 9904: if P_COMMIT = FND_API.G_TRUE then

9900: LogMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, 'Total Failed/Warning ' || g_failed_loan_cnt || ' loan(s)');
9901:
9902: -- Note: If possible delete the lnsDistribution records and corresponding events for AccountingFailed loans and then commit the below
9903:
9904: if P_COMMIT = FND_API.G_TRUE then
9905: COMMIT WORK;
9906: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Commited loans');
9907: end if;
9908:

Line 9910: x_return_status := FND_API.G_RET_STS_SUCCESS;

9906: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Commited loans');
9907: end if;
9908:
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,

Line 9914: p_encoded => FND_API.G_FALSE,

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:
9918: LogMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, l_api_name || ' -');

Line 9921: WHEN FND_API.G_EXC_ERROR THEN

9917:
9918: LogMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, l_api_name || ' -');
9919:
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');

Line 9923: x_return_status := FND_API.G_RET_STS_ERROR;

9919:
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

Line 9927: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN

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;
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');

Line 9929: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;

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;
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

Line 9935: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;

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;
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);

Line 10032: P_INIT_MSG_LIST => FND_API.G_TRUE,

10028:
10029: /* do accrual for all loans and stores all statements in g_last_all_statements */
10030: ACCRUE_LOANS_INTEREST(
10031: P_API_VERSION => 1.0,
10032: P_INIT_MSG_LIST => FND_API.G_TRUE,
10033: P_COMMIT => FND_API.G_TRUE,
10034: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,
10035: P_BORROWER_ID => BORROWER_ID,
10036: P_LEDGER_ID => LEDGER_ID,

Line 10033: P_COMMIT => FND_API.G_TRUE,

10029: /* do accrual for all loans and stores all statements in g_last_all_statements */
10030: ACCRUE_LOANS_INTEREST(
10031: P_API_VERSION => 1.0,
10032: P_INIT_MSG_LIST => FND_API.G_TRUE,
10033: P_COMMIT => FND_API.G_TRUE,
10034: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,
10035: P_BORROWER_ID => BORROWER_ID,
10036: P_LEDGER_ID => LEDGER_ID,
10037: P_ORG_ID => ORG_ID,

Line 10034: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,

10030: ACCRUE_LOANS_INTEREST(
10031: P_API_VERSION => 1.0,
10032: P_INIT_MSG_LIST => FND_API.G_TRUE,
10033: P_COMMIT => FND_API.G_TRUE,
10034: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,
10035: P_BORROWER_ID => BORROWER_ID,
10036: P_LEDGER_ID => LEDGER_ID,
10037: P_ORG_ID => ORG_ID,
10038: P_LOAN_ID => LOAN_ID,

Line 10212: IF FND_API.to_Boolean( p_init_msg_list ) THEN

10208: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'p_loan_amount_adj_id = ' || p_loan_amount_adj_id);
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

Line 10217: x_return_status := FND_API.G_RET_STS_SUCCESS;

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;
10218:
10219: drIndex := 0;
10220: crIndex := 0;
10221: l_dr_run_amount := 0;

Line 10346: RAISE FND_API.G_EXC_ERROR;

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);
10350: x_distribution_tbl := l_distributions;

Line 10352: IF FND_API.to_Boolean(p_commit)

10348:
10349: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'distribs2 count is ' || l_distributions.count);
10350: x_distribution_tbl := l_distributions;
10351:
10352: IF FND_API.to_Boolean(p_commit)
10353: THEN
10354: COMMIT WORK;
10355: END IF;
10356:

Line 10362: WHEN FND_API.G_EXC_ERROR THEN

10358:
10359: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, l_api_name || ' - END');
10360:
10361: EXCEPTION
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);

Line 10364: x_return_status := FND_API.G_RET_STS_ERROR;

10360:
10361: EXCEPTION
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

Line 10368: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN

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;
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);

Line 10370: x_return_status := FND_API.G_RET_STS_ERROR;

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;
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

Line 10376: x_return_status := FND_API.G_RET_STS_ERROR;

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;
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;

Line 10483: x_return_status := FND_API.G_RET_STS_SUCCESS;

10479:
10480: begin
10481:
10482: -- Initialize API return status to SUCCESS
10483: x_return_status := FND_API.G_RET_STS_SUCCESS;
10484:
10485: l_api_name := 'GENERATE_CCID_FOR_PROJECTS';
10486: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, l_api_name || ' - BEGIN');
10487: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'p_loan_id = ' || p_loan_id);

Line 10738: x_return_status := FND_API.G_RET_STS_ERROR;

10734:
10735: EXCEPTION
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: