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

APPS.LNS_DISTRIBUTIONS_PUB dependencies on FND_API

Line 93: IF FND_API.to_Boolean( p_init_msg_list ) THEN

89: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, l_api_name || ' - BEGIN');
90: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'p_loan_id ' || p_loan_id);
91:
92: -- Initialize message list IF p_init_msg_list is set to TRUE.
93: IF FND_API.to_Boolean( p_init_msg_list ) THEN
94: FND_MSG_PUB.initialize;
95: END IF;
96:
97: -- Initialize API return status to SUCCESS

Line 98: x_return_status := FND_API.G_RET_STS_SUCCESS;

94: FND_MSG_PUB.initialize;
95: END IF;
96:
97: -- Initialize API return status to SUCCESS
98: x_return_status := FND_API.G_RET_STS_SUCCESS;
99:
100: -- first complete accounting for any unprocessed events / documents for the loan transaction
101: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Calling lns_distributions_pub.onlineAccounting...');
102: lns_distributions_pub.onlineAccounting(p_loan_id => p_loan_id

Line 103: ,p_init_msg_list => fnd_api.g_false

99:
100: -- first complete accounting for any unprocessed events / documents for the loan transaction
101: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Calling lns_distributions_pub.onlineAccounting...');
102: lns_distributions_pub.onlineAccounting(p_loan_id => p_loan_id
103: ,p_init_msg_list => fnd_api.g_false
104: ,p_accounting_mode => 'F'
105: ,p_transfer_flag => 'Y'
106: ,p_offline_flag => 'N'
107: ,p_gl_posting_flag => 'N'

Line 113: RAISE FND_API.G_EXC_ERROR;

109: ,x_msg_count => l_msg_count
110: ,x_msg_data => l_msg_data);
111: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'l_return_status = ' || l_return_status);
112: if l_return_status <> 'S' then
113: RAISE FND_API.G_EXC_ERROR;
114: end if;
115:
116: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'fetching l_disbusement_id ');
117: open c_disbursements(p_loan_id);

Line 138: ,p_init_msg_list => fnd_api.g_false

134: ,p_disb_header_id => l_disbursement_id
135: ,p_event_type_code => 'FUTURE_DISBURSEMENT_CANCELLED'
136: ,p_event_date => l_gl_date
137: ,p_event_status => 'U'
138: ,p_init_msg_list => fnd_api.g_false
139: ,p_commit => fnd_api.g_false
140: ,p_bc_flag => 'Y'
141: ,x_event_id => l_event_id
142: ,x_return_status => l_return_status

Line 139: ,p_commit => fnd_api.g_false

135: ,p_event_type_code => 'FUTURE_DISBURSEMENT_CANCELLED'
136: ,p_event_date => l_gl_date
137: ,p_event_status => 'U'
138: ,p_init_msg_list => fnd_api.g_false
139: ,p_commit => fnd_api.g_false
140: ,p_bc_flag => 'Y'
141: ,x_event_id => l_event_id
142: ,x_return_status => l_return_status
143: ,x_msg_count => l_msg_count

Line 148: IF x_return_status <> FND_API.G_RET_STS_SUCCESS THEN

144: ,x_msg_data => l_msg_data);
145: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'l_return_status = ' || l_return_status);
146: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'l_event_id = ' || l_event_id);
147:
148: IF x_return_status <> FND_API.G_RET_STS_SUCCESS THEN
149: FND_MESSAGE.SET_NAME('LNS', 'LNS_ACCOUNTING_EVENT_ERROR');
150: FND_MSG_PUB.ADD;
151: logMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
152: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;

Line 152: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;

148: IF x_return_status <> FND_API.G_RET_STS_SUCCESS THEN
149: FND_MESSAGE.SET_NAME('LNS', 'LNS_ACCOUNTING_EVENT_ERROR');
150: FND_MSG_PUB.ADD;
151: logMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
152: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
153: END IF;
154:
155: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'stamping new event_id on distributions');
156: update lns_distributions

Line 174: ,p_init_msg_list => FND_API.G_FALSE

170:
171: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Calling PSA_BC_XLA_PUB.Budgetary_Control ' || l_event_id);
172: -- always pass P_BC_MODE = reserve as per shaniqua williams
173: PSA_BC_XLA_PUB.Budgetary_Control(p_api_version => 1.0
174: ,p_init_msg_list => FND_API.G_FALSE
175: ,x_return_status => l_return_status
176: ,x_msg_count => l_msg_count
177: ,x_msg_data => l_msg_data
178: ,p_application_id => 206

Line 193: x_return_status := FND_API.G_RET_STS_ERROR;

189:
190: -- we want to commit ONLY in the case of SUCCESS or ADVISORY
191: if (l_return_status <> 'S') then
192:
193: x_return_status := FND_API.G_RET_STS_ERROR;
194: FND_MESSAGE.SET_NAME('LNS', 'LNS_API_OTHERS_EXCEP');
195: FND_MESSAGE.SET_TOKEN('ERROR' ,'Call to PSA_BC_XLA_PUB.Budgetary_Control failed with Status Code = ' || l_status_code);
196: FND_MSG_PUB.ADD;
197: logMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));

Line 198: RAISE FND_API.G_EXC_ERROR;

194: FND_MESSAGE.SET_NAME('LNS', 'LNS_API_OTHERS_EXCEP');
195: FND_MESSAGE.SET_TOKEN('ERROR' ,'Call to PSA_BC_XLA_PUB.Budgetary_Control failed with Status Code = ' || l_status_code);
196: FND_MSG_PUB.ADD;
197: logMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
198: RAISE FND_API.G_EXC_ERROR;
199:
200: else
201: -- caller handle success status
202: null;

Line 211: IF FND_API.to_Boolean(p_commit)

207:
208: end if;
209:
210: x_return_status := l_return_status;
211: IF FND_API.to_Boolean(p_commit)
212: THEN
213: COMMIT WORK;
214: END IF;
215:

Line 220: WHEN FND_API.G_EXC_ERROR THEN

216: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, l_api_name || ' - END');
217:
218: EXCEPTION
219:
220: WHEN FND_API.G_EXC_ERROR THEN
221: ROLLBACK TO cancel_disbursements;
222: x_return_status := FND_API.G_RET_STS_ERROR;
223: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
224: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);

Line 222: x_return_status := FND_API.G_RET_STS_ERROR;

218: EXCEPTION
219:
220: WHEN FND_API.G_EXC_ERROR THEN
221: ROLLBACK TO cancel_disbursements;
222: x_return_status := FND_API.G_RET_STS_ERROR;
223: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
224: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
225:
226: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN

Line 226: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN

222: x_return_status := FND_API.G_RET_STS_ERROR;
223: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
224: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
225:
226: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
227: ROLLBACK TO cancel_disbursements;
228: x_return_status := FND_API.G_RET_STS_ERROR;
229: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
230: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);

Line 228: x_return_status := FND_API.G_RET_STS_ERROR;

224: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
225:
226: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
227: ROLLBACK TO cancel_disbursements;
228: x_return_status := FND_API.G_RET_STS_ERROR;
229: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
230: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
231:
232: WHEN OTHERS THEN

Line 234: x_return_status := FND_API.G_RET_STS_ERROR;

230: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
231:
232: WHEN OTHERS THEN
233: ROLLBACK TO cancel_disbursements;
234: x_return_status := FND_API.G_RET_STS_ERROR;
235: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
236: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
237:
238: end cancel_disbursements;

Line 456: IF FND_API.to_Boolean( p_init_msg_list ) THEN

452: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'p_loan_id = ' || p_loan_id);
453: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'p_budgetary_control_mode = ' || p_budgetary_control_mode);
454:
455: -- Initialize message list IF p_init_msg_list is set to TRUE.
456: IF FND_API.to_Boolean( p_init_msg_list ) THEN
457: FND_MSG_PUB.initialize;
458: END IF;
459:
460: -- Initialize API return status to SUCCESS

Line 461: x_return_status := FND_API.G_RET_STS_SUCCESS;

457: FND_MSG_PUB.initialize;
458: END IF;
459:
460: -- Initialize API return status to SUCCESS
461: x_return_status := FND_API.G_RET_STS_SUCCESS;
462:
463: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'fetching l_disbusement_id ');
464: open c_disbursements(p_loan_id);
465: fetch c_disbursements into l_disbursement_id;

Line 477: RAISE FND_API.G_EXC_ERROR;

473: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
474: FND_MESSAGE.SET_NAME('LNS', 'LNS_CREATE_DISB_SCHED');
475: FND_MSG_PUB.ADD;
476: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
477: RAISE FND_API.G_EXC_ERROR;
478: END IF;
479:
480: if (lns_utility_pub.IS_FED_FIN_ENABLED = 'Y' AND l_disbursement_id IS NOT NULL) then
481:

Line 503: ,p_init_msg_list => fnd_api.g_false

499: ,p_disb_header_id => l_disbursement_id
500: ,p_event_type_code => 'DIRECT_LOAN_APPROVED'
501: ,p_event_date => l_gl_date
502: ,p_event_status => 'U'
503: ,p_init_msg_list => fnd_api.g_false
504: ,p_commit => fnd_api.g_false
505: ,p_bc_flag => 'Y'
506: ,x_event_id => x_event_id
507: ,x_return_status => x_return_status

Line 504: ,p_commit => fnd_api.g_false

500: ,p_event_type_code => 'DIRECT_LOAN_APPROVED'
501: ,p_event_date => l_gl_date
502: ,p_event_status => 'U'
503: ,p_init_msg_list => fnd_api.g_false
504: ,p_commit => fnd_api.g_false
505: ,p_bc_flag => 'Y'
506: ,x_event_id => x_event_id
507: ,x_return_status => x_return_status
508: ,x_msg_count => x_msg_count

Line 513: IF x_return_status <> FND_API.G_RET_STS_SUCCESS THEN

509: ,x_msg_data => x_msg_data);
510: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'x_return_status = ' || x_return_status);
511: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'x_event_id ' || x_event_id);
512:
513: IF x_return_status <> FND_API.G_RET_STS_SUCCESS THEN
514: FND_MESSAGE.SET_NAME('LNS', 'LNS_ACCOUNTING_EVENT_ERROR');
515: FND_MSG_PUB.ADD;
516: logMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
517: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;

Line 517: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;

513: IF x_return_status <> FND_API.G_RET_STS_SUCCESS THEN
514: FND_MESSAGE.SET_NAME('LNS', 'LNS_ACCOUNTING_EVENT_ERROR');
515: FND_MSG_PUB.ADD;
516: logMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
517: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
518: END IF;
519:
520: -- stamp the eventID onto the lns_distributions table
521: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'stamping eventID on lns_distributions');

Line 549: ,p_init_msg_list => FND_API.G_FALSE

545: values (l_event_id, 'FAIL');
546:
547: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Calling PSA_BC_XLA_PUB.Budgetary_Control ' || l_event_id);
548: PSA_BC_XLA_PUB.Budgetary_Control(p_api_version => 1.0
549: ,p_init_msg_list => FND_API.G_FALSE
550: ,x_return_status => l_return_status
551: ,x_msg_count => l_msg_count
552: ,x_msg_data => l_msg_data
553: ,p_application_id => 206

Line 570: l_return_status := FND_API.G_RET_STS_ERROR;

566:
567: -- we want to commit ONLY in the case of SUCCESS or ADVISORY
568: if (l_return_status <> 'S' ) then
569:
570: l_return_status := FND_API.G_RET_STS_ERROR;
571: FND_MESSAGE.SET_NAME('LNS', 'LNS_API_OTHERS_EXCEP');
572: FND_MESSAGE.SET_TOKEN('ERROR' ,'Call to PSA_BC_XLA_PUB.Budgetary_Control failed with Status Code = ' || l_status_code);
573: FND_MSG_PUB.ADD;
574: logMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));

Line 575: RAISE FND_API.G_EXC_ERROR;

571: FND_MESSAGE.SET_NAME('LNS', 'LNS_API_OTHERS_EXCEP');
572: FND_MESSAGE.SET_TOKEN('ERROR' ,'Call to PSA_BC_XLA_PUB.Budgetary_Control failed with Status Code = ' || l_status_code);
573: FND_MSG_PUB.ADD;
574: logMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
575: RAISE FND_API.G_EXC_ERROR;
576:
577: else
578: if l_status_code NOT IN ('SUCCESS','ADVISORY') then
579: IF (l_status_code = 'PARTIAL') THEN

Line 583: RAISE FND_API.G_EXC_ERROR;

579: IF (l_status_code = 'PARTIAL') THEN
580: FND_MESSAGE.SET_NAME('LNS', 'LNS_FUND_CHK_PARTIAL');
581: FND_MSG_PUB.ADD;
582: logMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
583: RAISE FND_API.G_EXC_ERROR;
584: ELSE
585: FND_MESSAGE.SET_NAME('LNS', 'LNS_API_OTHERS_EXCEP');
586: FND_MESSAGE.SET_TOKEN('ERROR' ,'Call to PSA_BC_XLA_PUB.Budgetary_Control failed with Status Code = ' || l_status_code);
587: FND_MSG_PUB.ADD;

Line 589: RAISE FND_API.G_EXC_ERROR;

585: FND_MESSAGE.SET_NAME('LNS', 'LNS_API_OTHERS_EXCEP');
586: FND_MESSAGE.SET_TOKEN('ERROR' ,'Call to PSA_BC_XLA_PUB.Budgetary_Control failed with Status Code = ' || l_status_code);
587: FND_MSG_PUB.ADD;
588: logMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
589: RAISE FND_API.G_EXC_ERROR;
590: END IF;
591: end if;
592:
593: open c_obj_vers(p_loan_id);

Line 606: ,P_INIT_MSG_LIST => FND_API.G_FALSE

602: l_loan_header_rec.FUNDS_CHECK_DATE := sysdate;
603: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, l_api_name || 'updating loan');
604: LNS_LOAN_HEADER_PUB.UPDATE_LOAN(P_OBJECT_VERSION_NUMBER => l_version
605: ,P_LOAN_HEADER_REC => l_loan_header_rec
606: ,P_INIT_MSG_LIST => FND_API.G_FALSE
607: ,X_RETURN_STATUS => l_return_status
608: ,X_MSG_COUNT => l_msg_count
609: ,X_MSG_DATA => l_msg_data);
610: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'update loan status = ' || l_return_status);

Line 616: RAISE FND_API.G_EXC_ERROR;

612: if l_return_status <> 'S' then
613: FND_MESSAGE.SET_NAME('LNS', 'LNS_UPD_LOAN_FAIL');
614: FND_MSG_PUB.ADD;
615: logMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
616: RAISE FND_API.G_EXC_ERROR;
617: end if;
618:
619: end if; -- BC_API.RETURN_STATUS
620:

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

621: end if; -- l_funds_reserved_flag
622: x_budgetary_status_code := l_status_code;
623: x_return_status := l_return_status;
624:
625: IF (l_return_status = 'S' AND FND_API.to_Boolean(p_commit))
626: THEN
627: COMMIT WORK;
628: END IF;
629:

Line 636: WHEN FND_API.G_EXC_ERROR THEN

632: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, l_api_name || ' - END');
633:
634: EXCEPTION
635:
636: WHEN FND_API.G_EXC_ERROR THEN
637: ROLLBACK TO budgetary_control_pvt;
638: x_return_status := FND_API.G_RET_STS_ERROR;
639: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
640: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);

Line 638: x_return_status := FND_API.G_RET_STS_ERROR;

634: EXCEPTION
635:
636: WHEN FND_API.G_EXC_ERROR THEN
637: ROLLBACK TO budgetary_control_pvt;
638: x_return_status := FND_API.G_RET_STS_ERROR;
639: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
640: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
641:
642: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN

Line 642: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN

638: x_return_status := FND_API.G_RET_STS_ERROR;
639: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
640: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
641:
642: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
643: ROLLBACK TO budgetary_control_pvt;
644: x_return_status := FND_API.G_RET_STS_ERROR;
645: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
646: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);

Line 644: x_return_status := FND_API.G_RET_STS_ERROR;

640: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
641:
642: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
643: ROLLBACK TO budgetary_control_pvt;
644: x_return_status := FND_API.G_RET_STS_ERROR;
645: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
646: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
647:
648: WHEN OTHERS THEN

Line 650: x_return_status := FND_API.G_RET_STS_ERROR;

646: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
647:
648: WHEN OTHERS THEN
649: ROLLBACK TO budgetary_control_pvt;
650: x_return_status := FND_API.G_RET_STS_ERROR;
651: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
652: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
653:
654: end budgetary_control;

Line 749: RAISE FND_API.G_EXC_ERROR;

745:
746: FND_MESSAGE.SET_NAME('LNS', 'LNS_DEFAULT_DIST_NOT_FOUND');
747: FND_MSG_PUB.ADD;
748: logMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
749: RAISE FND_API.G_EXC_ERROR;
750:
751: end if;
752: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, l_api_name || ' - END');
753:

Line 893: IF FND_API.to_Boolean( p_init_msg_list ) THEN

889: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'p_include_loan_receivables = ' || p_include_loan_receivables);
890: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'p_distribution_type = ' || p_distribution_type);
891:
892: -- Initialize message list IF p_init_msg_list is set to TRUE.
893: IF FND_API.to_Boolean( p_init_msg_list ) THEN
894: FND_MSG_PUB.initialize;
895: END IF;
896:
897: -- Initialize API return status to SUCCESS

Line 898: x_return_status := FND_API.G_RET_STS_SUCCESS;

894: FND_MSG_PUB.initialize;
895: END IF;
896:
897: -- Initialize API return status to SUCCESS
898: x_return_status := FND_API.G_RET_STS_SUCCESS;
899:
900: n := 0;
901: k := 0;
902: l := 0;

Line 1039: RAISE FND_API.G_EXC_ERROR;

1035: when no_data_found then
1036: FND_MESSAGE.SET_NAME('LNS', 'LNS_DEFAULT_DIST_NOT_FOUND');
1037: FND_MSG_PUB.ADD;
1038: logMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
1039: RAISE FND_API.G_EXC_ERROR;
1040: End; -- c_default_info cursor
1041:
1042: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'distribs2 count is ' || l_distributions.count);
1043: x_distribution_tbl := l_distributions;

Line 1045: IF FND_API.to_Boolean(p_commit)

1041:
1042: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'distribs2 count is ' || l_distributions.count);
1043: x_distribution_tbl := l_distributions;
1044:
1045: IF FND_API.to_Boolean(p_commit)
1046: THEN
1047: COMMIT WORK;
1048: END IF;
1049:

Line 1055: WHEN FND_API.G_EXC_ERROR THEN

1051:
1052: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, l_api_name || ' - END');
1053:
1054: EXCEPTION
1055: WHEN FND_API.G_EXC_ERROR THEN
1056: ROLLBACK TO defaultDistributionsCatch;
1057: x_return_status := FND_API.G_RET_STS_ERROR;
1058: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
1059: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);

Line 1057: x_return_status := FND_API.G_RET_STS_ERROR;

1053:
1054: EXCEPTION
1055: WHEN FND_API.G_EXC_ERROR THEN
1056: ROLLBACK TO defaultDistributionsCatch;
1057: x_return_status := FND_API.G_RET_STS_ERROR;
1058: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
1059: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
1060:
1061: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN

Line 1061: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN

1057: x_return_status := FND_API.G_RET_STS_ERROR;
1058: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
1059: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
1060:
1061: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
1062: ROLLBACK TO defaultDistributionsCatch;
1063: x_return_status := FND_API.G_RET_STS_ERROR;
1064: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
1065: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);

Line 1063: x_return_status := FND_API.G_RET_STS_ERROR;

1059: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
1060:
1061: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
1062: ROLLBACK TO defaultDistributionsCatch;
1063: x_return_status := FND_API.G_RET_STS_ERROR;
1064: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
1065: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
1066:
1067: WHEN OTHERS THEN

Line 1069: x_return_status := FND_API.G_RET_STS_ERROR;

1065: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
1066:
1067: WHEN OTHERS THEN
1068: ROLLBACK TO defaultDistributionsCatch;
1069: x_return_status := FND_API.G_RET_STS_ERROR;
1070: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
1071: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
1072:
1073: end defaultDistributionsCatch;

Line 1138: IF FND_API.to_Boolean(p_init_msg_list) THEN

1134: -- Standard Start of API savepoint
1135: SAVEPOINT create_event;
1136:
1137: -- Initialize message list IF p_init_msg_list is set to TRUE.
1138: IF FND_API.to_Boolean(p_init_msg_list) THEN
1139: FND_MSG_PUB.initialize;
1140: END IF;
1141:
1142: -- Initialize API return status to SUCCESS

Line 1143: x_return_status := FND_API.G_RET_STS_SUCCESS;

1139: FND_MSG_PUB.initialize;
1140: END IF;
1141:
1142: -- Initialize API return status to SUCCESS
1143: x_return_status := FND_API.G_RET_STS_SUCCESS;
1144:
1145: -- ---------------------------------------------------------------------
1146: -- Api body
1147: -- ---------------------------------------------------------------------

Line 1172: IF x_return_status <> FND_API.G_RET_STS_SUCCESS THEN

1168: ,x_msg_data => x_msg_data);
1169: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'l_event_id = ' || l_event_id);
1170: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'x_return_status = ' || x_return_status);
1171:
1172: IF x_return_status <> FND_API.G_RET_STS_SUCCESS THEN
1173: FND_MESSAGE.SET_NAME('LNS', 'LNS_ACCOUNTING_EVENT_ERROR');
1174: FND_MSG_PUB.ADD;
1175: logMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
1176: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;

Line 1176: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;

1172: IF x_return_status <> FND_API.G_RET_STS_SUCCESS THEN
1173: FND_MESSAGE.SET_NAME('LNS', 'LNS_ACCOUNTING_EVENT_ERROR');
1174: FND_MSG_PUB.ADD;
1175: logMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
1176: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
1177: ELSE
1178: -- update the distributions table with proper event_id for valid disb_header_id
1179: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Updating lns_distributions...');
1180: update lns_distributions

Line 1198: WHEN FND_API.G_EXC_ERROR THEN

1194:
1195: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, l_api_name || ' - END');
1196:
1197: EXCEPTION
1198: WHEN FND_API.G_EXC_ERROR THEN
1199: ROLLBACK TO create_event;
1200: x_return_status := FND_API.G_RET_STS_ERROR;
1201: x_msg_count := l_msg_count;
1202: x_msg_data := l_msg_data;

Line 1200: x_return_status := FND_API.G_RET_STS_ERROR;

1196:
1197: EXCEPTION
1198: WHEN FND_API.G_EXC_ERROR THEN
1199: ROLLBACK TO create_event;
1200: x_return_status := FND_API.G_RET_STS_ERROR;
1201: x_msg_count := l_msg_count;
1202: x_msg_data := l_msg_data;
1203: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
1204: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);

Line 1206: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN

1202: x_msg_data := l_msg_data;
1203: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
1204: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
1205:
1206: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
1207: ROLLBACK TO create_event;
1208: x_return_status := FND_API.G_RET_STS_ERROR;
1209: x_msg_count := l_msg_count;
1210: x_msg_data := l_msg_data;

Line 1208: x_return_status := FND_API.G_RET_STS_ERROR;

1204: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
1205:
1206: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
1207: ROLLBACK TO create_event;
1208: x_return_status := FND_API.G_RET_STS_ERROR;
1209: x_msg_count := l_msg_count;
1210: x_msg_data := l_msg_data;
1211: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
1212: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);

Line 1216: x_return_status := FND_API.G_RET_STS_ERROR;

1212: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
1213:
1214: WHEN OTHERS THEN
1215: ROLLBACK TO create_event;
1216: x_return_status := FND_API.G_RET_STS_ERROR;
1217: x_msg_count := l_msg_count;
1218: x_msg_data := l_msg_data;
1219: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
1220: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);

Line 1284: RAISE FND_API.G_EXC_ERROR;

1280: logMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'failed to retrieve replacement natural account');
1281: FND_MESSAGE.SET_NAME('LNS', 'LNS_MFAR_CONFIGURATION_ERROR');
1282: FND_MSG_PUB.ADD;
1283: logMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
1284: RAISE FND_API.G_EXC_ERROR;
1285:
1286: end getNaturalSwapAccount;
1287:
1288: /*=========================================================================

Line 1351: RAISE FND_API.G_EXC_ERROR;

1347: Then
1348: FND_MESSAGE.SET_NAME('LNS', 'LNS_ERR_BUILDING_SEGMENTS');
1349: FND_MSG_PUB.ADD;
1350: logMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
1351: RAISE FND_API.G_EXC_ERROR;
1352: END IF;
1353:
1354: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Original segments:');
1355: for n in 1..l_num_segments loop

Line 1388: RAISE FND_API.G_EXC_ERROR;

1384: Then
1385: FND_MESSAGE.SET_NAME('LNS', 'LNS_CODE_COMBINATION_ERROR');
1386: FND_MSG_PUB.ADD;
1387: logMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
1388: RAISE FND_API.G_EXC_ERROR;
1389:
1390: END IF;
1391: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'new cc_id = ' || l_new_cc_id);
1392: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, l_api_name || ' - END');

Line 1399: RAISE FND_API.G_EXC_ERROR;

1395:
1396: exception
1397: when others then
1398: logMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'failed to create new code combination');
1399: RAISE FND_API.G_EXC_ERROR;
1400: end swap_code_combination;
1401:
1402:
1403: /*=========================================================================

Line 1468: RAISE FND_API.G_EXC_ERROR;

1464: When others then
1465: FND_MESSAGE.SET_NAME('LNS', 'LNS_MFAR_CONFIGURATION_ERROR');
1466: FND_MSG_PUB.ADD;
1467: logMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
1468: RAISE FND_API.G_EXC_ERROR;
1469: End;
1470: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'swap natural account with ' || l_natural_account_rec);
1471: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'COA ' || l_ledger_details.chart_of_accounts_id);
1472:

Line 1484: RAISE FND_API.G_EXC_ERROR;

1480: THEN
1481: FND_MESSAGE.SET_NAME('LNS', 'LNS_NO_NATURAL_ACCOUNT_SEGMENT');
1482: FND_MSG_PUB.ADD;
1483: logMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
1484: RAISE FND_API.G_EXC_ERROR;
1485:
1486: END IF;
1487: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'natural acct segment is ' || l_nat_acct_seg_number);
1488:

Line 1953: RAISE FND_API.G_EXC_ERROR;

1949: when others then
1950: FND_MESSAGE.SET_NAME('LNS', 'LNS_LEDGER_DETAILS_FAIL');
1951: FND_MSG_PUB.ADD;
1952: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
1953: RAISE FND_API.G_EXC_ERROR;
1954: end;
1955:
1956: end getLedgerDetails;
1957:

Line 2482: IF FND_API.to_Boolean( p_init_msg_list ) THEN

2478: l_api_name := 'validateAccounting1';
2479: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, l_api_name || ' - BEGIN');
2480:
2481: -- Initialize message list IF p_init_msg_list is set to TRUE.
2482: IF FND_API.to_Boolean( p_init_msg_list ) THEN
2483: FND_MSG_PUB.initialize;
2484: END IF;
2485:
2486: -- Initialize API return status to SUCCESS

Line 2487: x_return_status := FND_API.G_RET_STS_SUCCESS;

2483: FND_MSG_PUB.initialize;
2484: END IF;
2485:
2486: -- Initialize API return status to SUCCESS
2487: x_return_status := FND_API.G_RET_STS_SUCCESS;
2488:
2489: l_dist_percent_rec_orig := 0;
2490: l_dist_percent_rec_bill := 0;
2491: l_dist_percent_clear_orig := 0;

Line 2580: RAISE FND_API.G_EXC_ERROR;

2576:
2577: if l_num_receivables_acc <> l_num_receivables_ers then
2578: FND_MESSAGE.Set_Name('LNS', 'LNS_AR_RECEIVABLES_UNACC');
2579: FND_MSG_PUB.Add;
2580: RAISE FND_API.G_EXC_ERROR;
2581: end if;
2582: */
2583:
2584: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'comparing origination receivables to billing receivables count');

Line 2591: RAISE FND_API.G_EXC_ERROR;

2587: if l_loan_receivables_orig.count <> l_loan_receivables_bill.count then
2588: FND_MESSAGE.Set_Name('LNS', 'LNS_ACC_INVALID_RECEIVABLES');
2589: FND_MSG_PUB.Add;
2590: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
2591: RAISE FND_API.G_EXC_ERROR;
2592: end if;
2593:
2594: -- B. The account code combinations for the Loans Receivable accounts within
2595: -- Origination must be the same as the account code combinations for the Loans

Line 2606: RAISE FND_API.G_EXC_ERROR;

2602: if l_loan_receivables_orig(j).code_combination_id <> l_loan_receivables_bill(j).code_combination_id then
2603: FND_MESSAGE.Set_Name('LNS', 'LNS_ACC_LOAN_REC_CCIDS_UNMATCH');
2604: FND_MSG_PUB.Add;
2605: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
2606: RAISE FND_API.G_EXC_ERROR;
2607: end if;
2608:
2609: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'checking for duplicate IDs');
2610: if j < l_loan_receivables_orig.count then

Line 2618: RAISE FND_API.G_EXC_ERROR;

2614: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'found duplicate IDs');
2615: FND_MESSAGE.Set_Name('LNS', 'LNS_UNIQUE_CC_IDS');
2616: FND_MSG_PUB.Add;
2617: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
2618: RAISE FND_API.G_EXC_ERROR;
2619: end if;
2620: end if;
2621:
2622: -- F. The code combinations distribution percentages for each Loans Receivable

Line 2632: RAISE FND_API.G_EXC_ERROR;

2628: if l_loan_receivables_orig(j).distribution_percent <> l_loan_receivables_bill(j).distribution_percent then
2629: FND_MESSAGE.Set_Name('LNS', 'LNS_ACC_LOAN_REC_PER_UNMATCH');
2630: FND_MSG_PUB.Add;
2631: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
2632: RAISE FND_API.G_EXC_ERROR;
2633: end if;
2634:
2635: l_dist_percent_rec_orig := l_dist_percent_rec_orig + l_loan_receivables_orig(j).distribution_percent;
2636: l_dist_percent_rec_bill := l_dist_percent_rec_bill + l_loan_receivables_bill(j).distribution_percent;

Line 2650: RAISE FND_API.G_EXC_ERROR;

2646: if l_dist_percent_rec_orig <> 100 then
2647: FND_MESSAGE.Set_Name('LNS', 'LNS_ACC_ORIG_REC_PER_INVALID');
2648: FND_MSG_PUB.Add;
2649: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
2650: RAISE FND_API.G_EXC_ERROR;
2651: end if;
2652: end if;
2653:
2654: /*

Line 2660: RAISE FND_API.G_EXC_ERROR;

2656: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'loan recivables total percent: ' || l_dist_percent_rec_bill);
2657: if l_dist_percent_rec_bill <> 100 then
2658: FND_MESSAGE.Set_Name('LNS', 'LNS_ACC_BILL_REC_PER_INVALID');
2659: FND_MSG_PUB.Add;
2660: RAISE FND_API.G_EXC_ERROR;
2661: end if;
2662: */
2663:
2664: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'checking origination clearing total percentages');

Line 2670: RAISE FND_API.G_EXC_ERROR;

2666: /*
2667: if l_dist_percent_clear_orig <> 100 then
2668: FND_MESSAGE.Set_Name('LNS', 'LNS_ACC_ORIG_CLR_PER_INVALID');
2669: FND_MSG_PUB.Add;
2670: RAISE FND_API.G_EXC_ERROR;
2671: end if;
2672: */
2673: -- G. In the current release of 11i, there must be only one Principal Receivable
2674: -- account

Line 2681: RAISE FND_API.G_EXC_ERROR;

2677: if l_prin_receivables_bill.count <> 1 then
2678: FND_MESSAGE.Set_Name('LNS', 'LNS_ACC_MULT_PRIN_RECEIVABLE');
2679: FND_MSG_PUB.Add;
2680: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
2681: RAISE FND_API.G_EXC_ERROR;
2682: end if;
2683:
2684: -- H. In the current release of 11i, there must be only one Interest Receivable
2685: -- account

Line 2692: RAISE FND_API.G_EXC_ERROR;

2688: if l_int_receivables_bill.count <> 1 then
2689: FND_MESSAGE.Set_Name('LNS', 'LNS_ACC_MULT_INT_RECEIVABLE');
2690: FND_MSG_PUB.Add;
2691: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
2692: RAISE FND_API.G_EXC_ERROR;
2693: end if;
2694:
2695: -- I. There may be multiple Interest Income accounts
2696: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'checking Interest Income count');

Line 2702: RAISE FND_API.G_EXC_ERROR;

2698: if l_int_income_bill.count < 1 then
2699: FND_MESSAGE.Set_Name('LNS', 'LNS_ACC_NO_INTEREST_INCOME');
2700: FND_MSG_PUB.Add;
2701: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
2702: RAISE FND_API.G_EXC_ERROR;
2703: end if;
2704:
2705: -- J. The distribution percentages for Interest Income must add to 100%
2706: for j in 1..l_int_income_bill.count loop

Line 2716: RAISE FND_API.G_EXC_ERROR;

2712: if l_dist_percent_int_income <> 100 then
2713: FND_MESSAGE.Set_Name('LNS', 'LNS_ACC_INT_INCOME_PER_INVALID');
2714: FND_MSG_PUB.Add;
2715: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
2716: RAISE FND_API.G_EXC_ERROR;
2717: end if;
2718:
2719: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count
2720: ,p_data => x_msg_data);

Line 2725: WHEN FND_API.G_EXC_ERROR THEN

2721:
2722: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, l_api_name || ' - END');
2723:
2724: Exception
2725: WHEN FND_API.G_EXC_ERROR THEN
2726: x_return_status := FND_API.G_RET_STS_ERROR;
2727: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count
2728: ,p_data => x_msg_data);
2729: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);

Line 2726: x_return_status := FND_API.G_RET_STS_ERROR;

2722: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, l_api_name || ' - END');
2723:
2724: Exception
2725: WHEN FND_API.G_EXC_ERROR THEN
2726: x_return_status := FND_API.G_RET_STS_ERROR;
2727: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count
2728: ,p_data => x_msg_data);
2729: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
2730:

Line 2731: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN

2727: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count
2728: ,p_data => x_msg_data);
2729: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
2730:
2731: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
2732: x_return_status := FND_API.G_RET_STS_ERROR;
2733: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count
2734: ,p_data => x_msg_data);
2735: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);

Line 2732: x_return_status := FND_API.G_RET_STS_ERROR;

2728: ,p_data => x_msg_data);
2729: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
2730:
2731: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
2732: x_return_status := FND_API.G_RET_STS_ERROR;
2733: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count
2734: ,p_data => x_msg_data);
2735: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
2736:

Line 2738: x_return_status := FND_API.G_RET_STS_ERROR;

2734: ,p_data => x_msg_data);
2735: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
2736:
2737: WHEN OTHERS THEN
2738: x_return_status := FND_API.G_RET_STS_ERROR;
2739: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count
2740: ,p_data => x_msg_data);
2741: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
2742:

Line 2786: x_return_status := FND_API.G_RET_STS_SUCCESS;

2782: is
2783: begin
2784:
2785: -- Initialize API return status to SUCCESS
2786: x_return_status := FND_API.G_RET_STS_SUCCESS;
2787:
2788: end validateDefaultAccounting;
2789:
2790: /*========================================================================

Line 2881: IF FND_API.to_Boolean(p_init_msg_list) THEN

2877: -- Standard Start of API savepoint
2878: SAVEPOINT validateLoanLines;
2879:
2880: -- Initialize message list IF p_init_msg_list is set to TRUE.
2881: IF FND_API.to_Boolean(p_init_msg_list) THEN
2882: FND_MSG_PUB.initialize;
2883: END IF;
2884:
2885: -- Initialize API return status to SUCCESS

Line 2886: x_return_status := FND_API.G_RET_STS_SUCCESS;

2882: FND_MSG_PUB.initialize;
2883: END IF;
2884:
2885: -- Initialize API return status to SUCCESS
2886: x_return_status := FND_API.G_RET_STS_SUCCESS;
2887:
2888: -- ---------------------------------------------------------------------
2889: -- Api body
2890: -- ---------------------------------------------------------------------

Line 2920: RAISE FND_API.G_EXC_ERROR;

2916:
2917: if i <> 1 then
2918: if l_mfar then
2919: if l_psa_trx_type_id = -1 then
2920: RAISE FND_API.G_EXC_ERROR;
2921: end if;
2922: else
2923: if l_psa_trx_type_id <> -1 then
2924: RAISE FND_API.G_EXC_ERROR;

Line 2924: RAISE FND_API.G_EXC_ERROR;

2920: RAISE FND_API.G_EXC_ERROR;
2921: end if;
2922: else
2923: if l_psa_trx_type_id <> -1 then
2924: RAISE FND_API.G_EXC_ERROR;
2925: end if;
2926: end if;
2927: else
2928: if l_psa_trx_type_id = -1 then

Line 2979: WHEN FND_API.G_EXC_ERROR THEN

2975:
2976: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, l_api_name || ' - END');
2977:
2978: EXCEPTION
2979: WHEN FND_API.G_EXC_ERROR THEN
2980: ROLLBACK TO validateLoanLines;
2981: x_return_status := FND_API.G_RET_STS_ERROR;
2982: x_msg_count := l_msg_count;
2983: x_msg_data := l_msg_data;

Line 2981: x_return_status := FND_API.G_RET_STS_ERROR;

2977:
2978: EXCEPTION
2979: WHEN FND_API.G_EXC_ERROR THEN
2980: ROLLBACK TO validateLoanLines;
2981: x_return_status := FND_API.G_RET_STS_ERROR;
2982: x_msg_count := l_msg_count;
2983: x_msg_data := l_msg_data;
2984: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
2985: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);

Line 2987: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN

2983: x_msg_data := l_msg_data;
2984: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
2985: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
2986:
2987: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
2988: ROLLBACK TO validateLoanLines;
2989: x_return_status := FND_API.G_RET_STS_ERROR;
2990: x_msg_count := l_msg_count;
2991: x_msg_data := l_msg_data;

Line 2989: x_return_status := FND_API.G_RET_STS_ERROR;

2985: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
2986:
2987: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
2988: ROLLBACK TO validateLoanLines;
2989: x_return_status := FND_API.G_RET_STS_ERROR;
2990: x_msg_count := l_msg_count;
2991: x_msg_data := l_msg_data;
2992: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
2993: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);

Line 2997: x_return_status := FND_API.G_RET_STS_ERROR;

2993: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
2994:
2995: WHEN OTHERS THEN
2996: ROLLBACK TO validateLoanLines;
2997: x_return_status := FND_API.G_RET_STS_ERROR;
2998: x_msg_count := l_msg_count;
2999: x_msg_data := l_msg_data;
3000: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
3001: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);

Line 3072: IF FND_API.to_Boolean( p_init_msg_list ) THEN

3068: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'p_disb_header_id = ' || p_disb_header_id);
3069: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'p_loan_id = ' || p_loan_id);
3070:
3071: -- Initialize message list IF p_init_msg_list is set to TRUE.
3072: IF FND_API.to_Boolean( p_init_msg_list ) THEN
3073: FND_MSG_PUB.initialize;
3074: END IF;
3075:
3076: -- Initialize API return status to SUCCESS

Line 3077: x_return_status := FND_API.G_RET_STS_SUCCESS;

3073: FND_MSG_PUB.initialize;
3074: END IF;
3075:
3076: -- Initialize API return status to SUCCESS
3077: x_return_status := FND_API.G_RET_STS_SUCCESS;
3078:
3079: if p_disb_header_id is not null then
3080: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'p_disb_header_id = ' || p_disb_header_id);
3081: l_disb_header_id := p_disb_header_id;

Line 3106: ,p_init_msg_list => FND_API.G_TRUE

3102: --break up the distribution amounts for the disbursement
3103: -- insert into the distributions table
3104: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Calling defaultDistributionsCatch...');
3105: defaultDistributionsCatch(p_api_version => 1.0
3106: ,p_init_msg_list => FND_API.G_TRUE
3107: ,p_commit => p_commit
3108: ,p_loan_id => p_loan_id
3109: ,p_disb_header_id => l_disb_header_id
3110: ,p_include_loan_receivables => 'Y'

Line 3118: RAISE FND_API.G_EXC_ERROR;

3114: ,x_msg_count => l_msg_count
3115: ,x_msg_data => l_msg_data);
3116:
3117: if l_return_status <> 'S' then
3118: RAISE FND_API.G_EXC_ERROR;
3119: end if;
3120:
3121: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'l_distributionsCatch.count = ' || l_distributions.count);
3122: for j in 1..l_distributions.count loop

Line 3181: IF FND_API.to_Boolean(p_commit)

3177: do_insert_distributions(l_distributions, p_loan_id);
3178:
3179: end if;
3180:
3181: IF FND_API.to_Boolean(p_commit)
3182: THEN
3183: COMMIT WORK;
3184: END IF;
3185:

Line 3191: WHEN FND_API.G_EXC_ERROR THEN

3187: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, l_api_name || ' - END');
3188:
3189: EXCEPTION
3190:
3191: WHEN FND_API.G_EXC_ERROR THEN
3192: ROLLBACK TO create_DisbursementDistribs;
3193: x_return_status := FND_API.G_RET_STS_ERROR;
3194: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
3195: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);

Line 3193: x_return_status := FND_API.G_RET_STS_ERROR;

3189: EXCEPTION
3190:
3191: WHEN FND_API.G_EXC_ERROR THEN
3192: ROLLBACK TO create_DisbursementDistribs;
3193: x_return_status := FND_API.G_RET_STS_ERROR;
3194: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
3195: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
3196:
3197: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN

Line 3197: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN

3193: x_return_status := FND_API.G_RET_STS_ERROR;
3194: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
3195: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
3196:
3197: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
3198: ROLLBACK TO create_DisbursementDistribs;
3199: x_return_status := FND_API.G_RET_STS_ERROR;
3200: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
3201: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);

Line 3199: x_return_status := FND_API.G_RET_STS_ERROR;

3195: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
3196:
3197: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
3198: ROLLBACK TO create_DisbursementDistribs;
3199: x_return_status := FND_API.G_RET_STS_ERROR;
3200: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
3201: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
3202:
3203: WHEN OTHERS THEN

Line 3205: x_return_status := FND_API.G_RET_STS_ERROR;

3201: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
3202:
3203: WHEN OTHERS THEN
3204: ROLLBACK TO create_DisbursementDistribs;
3205: x_return_status := FND_API.G_RET_STS_ERROR;
3206: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
3207: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
3208:
3209: end create_DisbursementDistribs;

Line 3476: IF FND_API.to_Boolean( p_init_msg_list ) THEN

3472: logMessage(FND_LOG.level_statement, G_PKG_NAME, 'p_loan_id = ' || p_loan_id);
3473: logMessage(FND_LOG.level_statement, G_PKG_NAME, 'p_loan_class_code = ' || p_loan_class_code);
3474:
3475: -- Initialize message list IF p_init_msg_list is set to TRUE.
3476: IF FND_API.to_Boolean( p_init_msg_list ) THEN
3477: FND_MSG_PUB.initialize;
3478: END IF;
3479:
3480: -- Initialize API return status to SUCCESS

Line 3481: x_return_status := FND_API.G_RET_STS_SUCCESS;

3477: FND_MSG_PUB.initialize;
3478: END IF;
3479:
3480: -- Initialize API return status to SUCCESS
3481: x_return_status := FND_API.G_RET_STS_SUCCESS;
3482:
3483: -- initialize variables
3484: l_distributions_count := 0;
3485: l_distributionsCatch_count := 0;

Line 3531: if l_return_status <> FND_API.G_RET_STS_SUCCESS then

3527: ,x_msg_count => l_msg_count
3528: ,x_msg_data => l_msg_data);
3529:
3530: logMessage(FND_LOG.level_statement, G_PKG_NAME, 'l_return_status = ' || l_return_status);
3531: if l_return_status <> FND_API.G_RET_STS_SUCCESS then
3532: FND_MESSAGE.SET_NAME('LNS', 'LNS_DEFAULT_DIST_NOT_FOUND');
3533: FND_MSG_PUB.ADD;
3534: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
3535: RAISE FND_API.G_EXC_ERROR;

Line 3535: RAISE FND_API.G_EXC_ERROR;

3531: if l_return_status <> FND_API.G_RET_STS_SUCCESS then
3532: FND_MESSAGE.SET_NAME('LNS', 'LNS_DEFAULT_DIST_NOT_FOUND');
3533: FND_MSG_PUB.ADD;
3534: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
3535: RAISE FND_API.G_EXC_ERROR;
3536: end if;
3537:
3538: /* delete any rows for this loan before inheritance do not delete FEE_RECEIVABLE or FEE_INCOME rows*/
3539: logMessage(FND_LOG.level_statement, G_PKG_NAME, 'Deleting any existing accounting rows except FEE_RECEIVABLE or FEE_INCOME...');

Line 3564: RAISE FND_API.G_EXC_ERROR;

3560: exception
3561: when no_data_found then
3562: FND_MESSAGE.SET_NAME('LNS', 'LNS_NO_SUBSIDY_RATE');
3563: FND_MSG_PUB.ADD;
3564: RAISE FND_API.G_EXC_ERROR;
3565: end;
3566:
3567: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, l_api_name || ' l_subsidy_rate ' || l_subsidy_rate );
3568:

Line 3586: RAISE FND_API.G_EXC_ERROR;

3582: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, l_api_name || ' update loan status = ' || l_return_status);
3583: if l_return_status <> 'S' then
3584: FND_MESSAGE.SET_NAME('LNS', 'LNS_UPD_LOAN_FAIL');
3585: FND_MSG_PUB.ADD;
3586: RAISE FND_API.G_EXC_ERROR;
3587: end if;
3588: */
3589: logMessage(FND_LOG.level_statement, G_PKG_NAME, 'DIRECT LOAN INHERITANCE');
3590:

Line 3596: ,p_commit => FND_API.G_FALSE

3592: -- inherit based on loan class + type ONLY
3593: logMessage(FND_LOG.level_statement, G_PKG_NAME, 'Calling defaultDistributionsCatch...');
3594: defaultDistributionsCatch(p_api_version => 1.0
3595: ,p_init_msg_list => p_init_msg_list
3596: ,p_commit => FND_API.G_FALSE
3597: ,p_loan_id => p_loan_id
3598: ,p_disb_header_id => null
3599: ,p_include_loan_receivables => 'Y'
3600: ,p_distribution_type => 'BILLING'

Line 3607: RAISE FND_API.G_EXC_ERROR;

3603: ,x_msg_count => l_msg_count
3604: ,x_msg_data => l_msg_data);
3605: logMessage(FND_LOG.level_statement, G_PKG_NAME, 'l_return_status = ' || l_return_status);
3606: if l_return_status <> 'S' then
3607: RAISE FND_API.G_EXC_ERROR;
3608: end if;
3609:
3610: -- we establish the distributions for the first DISBURSEMENT only
3611: -- in order to process Budgetary Control Information

Line 3616: ,p_commit => FND_API.G_FALSE

3612: -- in SLA Transaction Line Object
3613: logMessage(FND_LOG.level_statement, G_PKG_NAME, 'Calling create_DisbursementDistribs...');
3614: create_DisbursementDistribs(p_api_version => 1.0
3615: ,p_init_msg_list => p_init_msg_list
3616: ,p_commit => FND_API.G_FALSE
3617: ,p_loan_id => p_loan_id
3618: ,p_disb_header_id => null
3619: ,x_return_status => l_return_status
3620: ,x_msg_count => l_msg_count

Line 3624: RAISE FND_API.G_EXC_ERROR;

3620: ,x_msg_count => l_msg_count
3621: ,x_msg_data => l_msg_data);
3622: logMessage(FND_LOG.level_statement, G_PKG_NAME, 'l_return_status = ' || l_return_status);
3623: if l_return_status <> 'S' then
3624: RAISE FND_API.G_EXC_ERROR;
3625: end if;
3626:
3627: elsif p_loan_class_code = 'ERS' then
3628:

Line 3662: RAISE FND_API.G_EXC_ERROR;

3658: FND_MESSAGE.SET_NAME('LNS', 'LNS_CHK_UPG_FAIL');
3659: FND_MESSAGE.SET_TOKEN('DOC_NUM', l_trx_number);
3660: FND_MSG_PUB.ADD;
3661: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
3662: RAISE FND_API.G_EXC_ERROR;
3663: else
3664: if l_upgrade_status <> 'Y' then
3665: FND_MESSAGE.SET_NAME('LNS', 'LNS_INVALID_TRX');
3666: FND_MESSAGE.SET_TOKEN('DOC_NUM', l_trx_number);

Line 3669: RAISE FND_API.G_EXC_ERROR;

3665: FND_MESSAGE.SET_NAME('LNS', 'LNS_INVALID_TRX');
3666: FND_MESSAGE.SET_TOKEN('DOC_NUM', l_trx_number);
3667: FND_MSG_PUB.ADD;
3668: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
3669: RAISE FND_API.G_EXC_ERROR;
3670: end if;
3671: end if;
3672:
3673: end loop;

Line 3745: RAISE FND_API.G_EXC_ERROR;

3741: END LOOP;
3742:
3743: close c_acc_errors;
3744:
3745: RAISE FND_API.G_EXC_ERROR;
3746: else
3747: logMessage(FND_LOG.level_statement, G_PKG_NAME, 'Online accounting SUCCESS! ');
3748: end if;
3749:

Line 3765: RAISE FND_API.G_EXC_ERROR;

3761: THEN
3762: FND_MESSAGE.SET_NAME('LNS', 'LNS_NO_NATURAL_ACCOUNT_SEGMENT');
3763: FND_MSG_PUB.ADD;
3764: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
3765: RAISE FND_API.G_EXC_ERROR;
3766: END IF;
3767: logMessage(FND_LOG.level_statement, G_PKG_NAME, 'Natural acct segment = ' || l_nat_acct_seg_number);
3768:
3769: -- here we establish the loan clearing first

Line 3809: RAISE FND_API.G_EXC_ERROR;

3805: --logMessage(FND_LOG.LEVEL_UNEX, G_PKG_NAME, 'Failed to inherit receivables distributions');
3806: FND_MESSAGE.SET_NAME('LNS', 'LNS_INHERIT_DIST_NOT_FOUND');
3807: FND_MSG_PUB.ADD;
3808: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
3809: RAISE FND_API.G_EXC_ERROR;
3810: end;
3811:
3812: --logMessage(FND_LOG.level_statement, G_PKG_NAME, 'After loan clearing lines calculated. total amount due = ' || l_total_amount_due);
3813:

Line 3887: RAISE FND_API.G_EXC_ERROR;

3883: -- logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, 'failed to inherit receivables distributions');
3884: FND_MESSAGE.SET_NAME('LNS', 'LNS_INHERIT_DIST_NOT_FOUND');
3885: FND_MSG_PUB.ADD;
3886: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
3887: RAISE FND_API.G_EXC_ERROR;
3888: end;
3889:
3890: else
3891: logMessage(FND_LOG.level_statement, G_PKG_NAME, 'NO ACCOUNTED ADJUSTMENT EXISTS');

Line 3974: ,p_init_msg_list => FND_API.G_FALSE

3970: -- inherit remaining account_names based on loan class + type for
3971: -- principal / interest receivable, interest income
3972: logMessage(FND_LOG.level_statement, G_PKG_NAME, 'Calling defaultDistributionsCatch...');
3973: defaultDistributionsCatch(p_api_version => 1.0
3974: ,p_init_msg_list => FND_API.G_FALSE
3975: ,p_commit => FND_API.G_FALSE
3976: ,p_loan_id => p_loan_id
3977: ,p_disb_header_id => null
3978: ,p_include_loan_receivables => l_include_receivables

Line 3975: ,p_commit => FND_API.G_FALSE

3971: -- principal / interest receivable, interest income
3972: logMessage(FND_LOG.level_statement, G_PKG_NAME, 'Calling defaultDistributionsCatch...');
3973: defaultDistributionsCatch(p_api_version => 1.0
3974: ,p_init_msg_list => FND_API.G_FALSE
3975: ,p_commit => FND_API.G_FALSE
3976: ,p_loan_id => p_loan_id
3977: ,p_disb_header_id => null
3978: ,p_include_loan_receivables => l_include_receivables
3979: ,p_distribution_type => null

Line 3986: RAISE FND_API.G_EXC_ERROR;

3982: ,x_msg_count => l_msg_count
3983: ,x_msg_data => l_msg_data);
3984: logMessage(FND_LOG.level_statement, G_PKG_NAME, 'l_return_status = ' || l_return_status);
3985: if l_return_status <> 'S' then
3986: RAISE FND_API.G_EXC_ERROR;
3987: end if;
3988:
3989: End if; --loan class
3990:

Line 4043: RAISE FND_API.G_EXC_ERROR;

4039: if l_return_status <> 'S' then
4040: FND_MESSAGE.SET_NAME('LNS', 'LNS_DEFAULT_DIST_NOT_FOUND');
4041: FND_MSG_PUB.ADD;
4042: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
4043: RAISE FND_API.G_EXC_ERROR;
4044: end if;
4045:
4046: IF FND_API.to_Boolean(p_commit) THEN
4047: COMMIT WORK;

Line 4046: IF FND_API.to_Boolean(p_commit) THEN

4042: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
4043: RAISE FND_API.G_EXC_ERROR;
4044: end if;
4045:
4046: IF FND_API.to_Boolean(p_commit) THEN
4047: COMMIT WORK;
4048: END IF;
4049:
4050: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);

Line 4055: WHEN FND_API.G_EXC_ERROR THEN

4051: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, l_api_name || ' - END');
4052:
4053: EXCEPTION
4054:
4055: WHEN FND_API.G_EXC_ERROR THEN
4056: ROLLBACK TO defaultDistributions;
4057: x_return_status := FND_API.G_RET_STS_ERROR;
4058: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
4059: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);

Line 4057: x_return_status := FND_API.G_RET_STS_ERROR;

4053: EXCEPTION
4054:
4055: WHEN FND_API.G_EXC_ERROR THEN
4056: ROLLBACK TO defaultDistributions;
4057: x_return_status := FND_API.G_RET_STS_ERROR;
4058: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
4059: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
4060:
4061: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN

Line 4061: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN

4057: x_return_status := FND_API.G_RET_STS_ERROR;
4058: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
4059: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
4060:
4061: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
4062: ROLLBACK TO defaultDistributions;
4063: x_return_status := FND_API.G_RET_STS_ERROR;
4064: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
4065: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);

Line 4063: x_return_status := FND_API.G_RET_STS_ERROR;

4059: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
4060:
4061: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
4062: ROLLBACK TO defaultDistributions;
4063: x_return_status := FND_API.G_RET_STS_ERROR;
4064: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
4065: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
4066:
4067: WHEN OTHERS THEN

Line 4069: x_return_status := FND_API.G_RET_STS_ERROR;

4065: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
4066:
4067: WHEN OTHERS THEN
4068: ROLLBACK TO defaultDistributions;
4069: x_return_status := FND_API.G_RET_STS_ERROR;
4070: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
4071: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
4072:
4073: end defaultDistributions;

Line 4174: x_return_status := FND_API.G_RET_STS_SUCCESS;

4170: l_api_name := 'onlineAccounting';
4171:
4172: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, l_api_name || ' - BEGIN');
4173: -- Initialize API return status to SUCCESS
4174: x_return_status := FND_API.G_RET_STS_SUCCESS;
4175: -- Initialize message list IF p_init_msg_list is set to TRUE.
4176: IF FND_API.to_Boolean( p_init_msg_list ) THEN
4177: FND_MSG_PUB.initialize;
4178: END IF;

Line 4176: IF FND_API.to_Boolean( p_init_msg_list ) THEN

4172: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, l_api_name || ' - BEGIN');
4173: -- Initialize API return status to SUCCESS
4174: x_return_status := FND_API.G_RET_STS_SUCCESS;
4175: -- Initialize message list IF p_init_msg_list is set to TRUE.
4176: IF FND_API.to_Boolean( p_init_msg_list ) THEN
4177: FND_MSG_PUB.initialize;
4178: END IF;
4179:
4180: open c_loan_info(p_loan_id);

Line 4260: RAISE FND_API.G_EXC_ERROR;

4256:
4257: FND_MESSAGE.SET_NAME('XLA', 'XLA_ONLINE_ACCTG_ERROR');
4258: FND_MSG_PUB.Add;
4259: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
4260: RAISE FND_API.G_EXC_ERROR;
4261:
4262: elsif l_retcode = 1 then
4263:
4264: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'online accounting failed ' || l_errbuf);

Line 4296: RAISE FND_API.G_EXC_ERROR;

4292: END LOOP;
4293:
4294: close c_acc_errors;
4295:
4296: RAISE FND_API.G_EXC_ERROR;
4297: end if;
4298:
4299: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
4300: commit;

Line 4305: WHEN FND_API.G_EXC_ERROR THEN

4301: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, l_api_name || ' - END');
4302:
4303: EXCEPTION
4304:
4305: WHEN FND_API.G_EXC_ERROR THEN
4306: ROLLBACK TO onlineAccounting;
4307: x_return_status := FND_API.G_RET_STS_ERROR;
4308: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
4309: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);

Line 4307: x_return_status := FND_API.G_RET_STS_ERROR;

4303: EXCEPTION
4304:
4305: WHEN FND_API.G_EXC_ERROR THEN
4306: ROLLBACK TO onlineAccounting;
4307: x_return_status := FND_API.G_RET_STS_ERROR;
4308: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
4309: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
4310:
4311: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN

Line 4311: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN

4307: x_return_status := FND_API.G_RET_STS_ERROR;
4308: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
4309: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
4310:
4311: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
4312: ROLLBACK TO onlineAccounting;
4313: x_return_status := FND_API.G_RET_STS_ERROR;
4314: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
4315: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);

Line 4313: x_return_status := FND_API.G_RET_STS_ERROR;

4309: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
4310:
4311: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
4312: ROLLBACK TO onlineAccounting;
4313: x_return_status := FND_API.G_RET_STS_ERROR;
4314: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
4315: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
4316:
4317: WHEN OTHERS THEN

Line 4319: x_return_status := FND_API.G_RET_STS_ERROR;

4315: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
4316:
4317: WHEN OTHERS THEN
4318: ROLLBACK TO onlineAccounting;
4319: x_return_status := FND_API.G_RET_STS_ERROR;
4320: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
4321: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
4322:
4323: end onlineAccounting;

Line 4406: RAISE FND_API.G_EXC_ERROR;

4402: -- LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'ERROR: Loan must be set.');
4403: FND_MESSAGE.SET_NAME('LNS', 'LNS_NO_LOAN');
4404: FND_MSG_PUB.Add;
4405: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
4406: RAISE FND_API.G_EXC_ERROR;
4407:
4408: end if;
4409:
4410: open c_loan_info(P_LOAN_ID);

Line 4430: ,p_init_msg_list => fnd_api.g_false

4426: ,p_disb_header_id => -1
4427: ,p_event_type_code => 'APPROVED'
4428: ,p_event_date => l_gl_date
4429: ,p_event_status => 'U'
4430: ,p_init_msg_list => fnd_api.g_false
4431: ,p_commit => fnd_api.g_false
4432: ,p_bc_flag => 'N'
4433: ,x_event_id => x_event_id
4434: ,x_return_status => l_return_status

Line 4431: ,p_commit => fnd_api.g_false

4427: ,p_event_type_code => 'APPROVED'
4428: ,p_event_date => l_gl_date
4429: ,p_event_status => 'U'
4430: ,p_init_msg_list => fnd_api.g_false
4431: ,p_commit => fnd_api.g_false
4432: ,p_bc_flag => 'N'
4433: ,x_event_id => x_event_id
4434: ,x_return_status => l_return_status
4435: ,x_msg_count => l_msg_count

Line 4440: IF l_return_status <> FND_API.G_RET_STS_SUCCESS THEN

4436: ,x_msg_data => l_msg_data);
4437: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'event_id = ' || x_event_id);
4438: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'l_return_status = ' || l_return_status);
4439:
4440: IF l_return_status <> FND_API.G_RET_STS_SUCCESS THEN
4441: FND_MESSAGE.SET_NAME('LNS', 'LNS_ACCOUNTING_EVENT_ERROR');
4442: FND_MSG_PUB.ADD;
4443: --l_last_api_called := 'LNS_XLA_EVENTS.create_event';
4444: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));

Line 4445: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;

4441: FND_MESSAGE.SET_NAME('LNS', 'LNS_ACCOUNTING_EVENT_ERROR');
4442: FND_MSG_PUB.ADD;
4443: --l_last_api_called := 'LNS_XLA_EVENTS.create_event';
4444: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
4445: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
4446: END IF;
4447:
4448:
4449:

Line 4453: ,p_init_msg_list => FND_API.G_TRUE

4449:
4450: -- we should do online accounting in batch mode here
4451: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Calling Lns_distributions_pub.defaultDistributions...');
4452: Lns_distributions_pub.defaultDistributions(p_api_version => 1.0
4453: ,p_init_msg_list => FND_API.G_TRUE
4454: ,p_commit => FND_API.G_FALSE
4455: ,p_loan_id => P_LOAN_ID
4456: ,p_loan_class_code => l_loan_class_code
4457: ,x_return_status => l_return_status

Line 4454: ,p_commit => FND_API.G_FALSE

4450: -- we should do online accounting in batch mode here
4451: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Calling Lns_distributions_pub.defaultDistributions...');
4452: Lns_distributions_pub.defaultDistributions(p_api_version => 1.0
4453: ,p_init_msg_list => FND_API.G_TRUE
4454: ,p_commit => FND_API.G_FALSE
4455: ,p_loan_id => P_LOAN_ID
4456: ,p_loan_class_code => l_loan_class_code
4457: ,x_return_status => l_return_status
4458: ,x_msg_count => l_msg_count

Line 4462: IF l_return_status <> FND_API.G_RET_STS_SUCCESS THEN

4458: ,x_msg_count => l_msg_count
4459: ,x_msg_data => l_msg_data);
4460: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'l_return_status = ' || l_return_status);
4461:
4462: IF l_return_status <> FND_API.G_RET_STS_SUCCESS THEN
4463: -- logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Call to Lns_distributions_pub.defaultDistributions failed with status ' || l_return_status);
4464: -- fnd_file.put_line(FND_FILE.LOG, 'FAILED TO INHERIT DISTRIBUTIONS');
4465: --l_last_api_called := 'Lns_distributions_pub.defaultDistributions';
4466: RAISE FND_API.G_EXC_ERROR;

Line 4466: RAISE FND_API.G_EXC_ERROR;

4462: IF l_return_status <> FND_API.G_RET_STS_SUCCESS THEN
4463: -- logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Call to Lns_distributions_pub.defaultDistributions failed with status ' || l_return_status);
4464: -- fnd_file.put_line(FND_FILE.LOG, 'FAILED TO INHERIT DISTRIBUTIONS');
4465: --l_last_api_called := 'Lns_distributions_pub.defaultDistributions';
4466: RAISE FND_API.G_EXC_ERROR;
4467: ELSE
4468:
4469: if x_event_id is not null then
4470: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Updating lns_distributions...');

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

4478:
4479: -- finally update the loan header
4480: l_loan_header_rec.loan_id := P_LOAN_ID;
4481: l_loan_header_rec.loan_status := 'ACTIVE';
4482: l_loan_header_rec.secondary_status := FND_API.G_MISS_CHAR;
4483: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Before call to LNS_LOAN_HEADER_PUB.update_loan');
4484: LNS_LOAN_HEADER_PUB.update_loan(p_init_msg_list => FND_API.G_FALSE
4485: ,p_loan_header_rec => l_loan_header_rec
4486: ,p_object_version_number => l_object_version_number

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

4480: l_loan_header_rec.loan_id := P_LOAN_ID;
4481: l_loan_header_rec.loan_status := 'ACTIVE';
4482: l_loan_header_rec.secondary_status := FND_API.G_MISS_CHAR;
4483: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Before call to LNS_LOAN_HEADER_PUB.update_loan');
4484: LNS_LOAN_HEADER_PUB.update_loan(p_init_msg_list => FND_API.G_FALSE
4485: ,p_loan_header_rec => l_loan_header_rec
4486: ,p_object_version_number => l_object_version_number
4487: ,x_return_status => l_return_status
4488: ,x_msg_count => l_msg_count

Line 4495: IF l_return_status <> FND_API.G_RET_STS_SUCCESS THEN

4491: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'l_msg_data = ' || l_msg_data);
4492:
4493: END IF;
4494:
4495: IF l_return_status <> FND_API.G_RET_STS_SUCCESS THEN
4496: RAISE FND_API.G_EXC_ERROR;
4497: else
4498: -- now check if 0th installment needs billing
4499:

Line 4496: RAISE FND_API.G_EXC_ERROR;

4492:
4493: END IF;
4494:
4495: IF l_return_status <> FND_API.G_RET_STS_SUCCESS THEN
4496: RAISE FND_API.G_EXC_ERROR;
4497: else
4498: -- now check if 0th installment needs billing
4499:
4500: /* check to start billing for 0-th installment */

Line 4540: l_return_status := FND_API.G_RET_STS_UNEXP_ERROR;

4536: null,
4537: null);
4538:
4539: if l_request_id = 0 then
4540: l_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
4541: FND_MESSAGE.SET_NAME('LNS', 'LNS_BILLING_REQUEST_FAILED');
4542: FND_MSG_PUB.Add;
4543: l_last_api_called := 'FND_REQUEST.SUBMIT_REQUEST for 0th installment billing';
4544: RAISE FND_API.G_EXC_ERROR;

Line 4544: RAISE FND_API.G_EXC_ERROR;

4540: l_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
4541: FND_MESSAGE.SET_NAME('LNS', 'LNS_BILLING_REQUEST_FAILED');
4542: FND_MSG_PUB.Add;
4543: l_last_api_called := 'FND_REQUEST.SUBMIT_REQUEST for 0th installment billing';
4544: RAISE FND_API.G_EXC_ERROR;
4545: else
4546: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Successfully submited Billing Concurrent Program to bill 0-th installment. Request id = ' || l_request_id);
4547: end if;
4548:

Line 4564: RETCODE := FND_API.G_RET_STS_ERROR;

4560: WHEN others THEN
4561: l_return := FND_CONCURRENT.SET_COMPLETION_STATUS(
4562: status => 'ERROR',
4563: message => 'Generate Distributions process has failed. Please review log file.');
4564: RETCODE := FND_API.G_RET_STS_ERROR;
4565: fnd_msg_pub.count_and_get(p_count => l_msg_count, p_data => ERRBUF);
4566: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, ' ');
4567: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, '-------------------');
4568: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Generate Distributions process has failed!');

Line 4596: IF FND_API.to_Boolean( p_init_msg_list ) THEN

4592: logmessage(fnd_log.level_statement, G_PKG_NAME, 'p_loan_id = ' || p_loan_id);
4593: logmessage(fnd_log.level_statement, G_PKG_NAME, 'p_loan_class_code = ' || p_loan_class_code);
4594:
4595: -- Initialize message list IF p_init_msg_list is set to TRUE.
4596: IF FND_API.to_Boolean( p_init_msg_list ) THEN
4597: FND_MSG_PUB.initialize;
4598: END IF;
4599:
4600: logMessage(FND_LOG.level_statement, G_PKG_NAME, 'Calling defaultDistributionsCatch...');

Line 4603: ,p_init_msg_list => FND_API.G_TRUE

4599:
4600: logMessage(FND_LOG.level_statement, G_PKG_NAME, 'Calling defaultDistributionsCatch...');
4601: LNS_DISTRIBUTIONS_PUB.defaultDistributionsCatch(
4602: p_api_version => 1.0
4603: ,p_init_msg_list => FND_API.G_TRUE
4604: ,p_commit => FND_API.G_FALSE
4605: ,p_loan_id => p_loan_id
4606: ,p_disb_header_id => null
4607: ,p_include_loan_receivables => 'Y'

Line 4604: ,p_commit => FND_API.G_FALSE

4600: logMessage(FND_LOG.level_statement, G_PKG_NAME, 'Calling defaultDistributionsCatch...');
4601: LNS_DISTRIBUTIONS_PUB.defaultDistributionsCatch(
4602: p_api_version => 1.0
4603: ,p_init_msg_list => FND_API.G_TRUE
4604: ,p_commit => FND_API.G_FALSE
4605: ,p_loan_id => p_loan_id
4606: ,p_disb_header_id => null
4607: ,p_include_loan_receivables => 'Y'
4608: ,p_distribution_type => null

Line 4615: RAISE FND_API.G_EXC_ERROR;

4611: ,x_msg_count => l_msg_count
4612: ,x_msg_data => l_msg_data);
4613: logMessage(FND_LOG.level_statement, G_PKG_NAME, 'l_return_status = ' || l_return_status);
4614: if l_return_status <> 'S' then
4615: RAISE FND_API.G_EXC_ERROR;
4616: end if;
4617:
4618: logMessage(FND_LOG.level_statement, G_PKG_NAME, 'l_distributionsCatch.count = ' || l_distributionsCatch.count);
4619:

Line 4625: RAISE FND_API.G_EXC_ERROR;

4621: lns_distributions_pub.do_insert_distributions(
4622: p_distributions_tbl => l_distributionsCatch
4623: ,p_loan_id => p_loan_id);
4624: if l_return_status <> 'S' then
4625: RAISE FND_API.G_EXC_ERROR;
4626: end if;
4627:
4628: -- validate the accounting rows here
4629: logMessage(FND_LOG.level_statement, G_PKG_NAME, 'Calling validateAccounting...');

Line 4631: ,p_init_msg_list => FND_API.G_TRUE

4627:
4628: -- validate the accounting rows here
4629: logMessage(FND_LOG.level_statement, G_PKG_NAME, 'Calling validateAccounting...');
4630: lns_distributions_pub.validateAccounting(p_loan_id => p_loan_id
4631: ,p_init_msg_list => FND_API.G_TRUE
4632: ,x_return_status => l_return_status
4633: ,x_msg_count => l_msg_count
4634: ,x_msg_data => l_msg_data);
4635:

Line 4641: RAISE FND_API.G_EXC_ERROR;

4637: if l_return_status <> 'S' then
4638: FND_MESSAGE.SET_NAME('LNS', 'LNS_DEFAULT_DIST_NOT_FOUND');
4639: FND_MSG_PUB.ADD;
4640: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
4641: RAISE FND_API.G_EXC_ERROR;
4642: end if;
4643:
4644: x_return_status := fnd_api.g_ret_sts_success;
4645: logmessage(fnd_log.level_procedure, G_PKG_NAME, g_pkg_name || '.' || l_api_name || ' -');

Line 4644: x_return_status := fnd_api.g_ret_sts_success;

4640: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
4641: RAISE FND_API.G_EXC_ERROR;
4642: end if;
4643:
4644: x_return_status := fnd_api.g_ret_sts_success;
4645: logmessage(fnd_log.level_procedure, G_PKG_NAME, g_pkg_name || '.' || l_api_name || ' -');
4646:
4647: EXCEPTION
4648: WHEN others THEN

Line 4649: x_return_status := fnd_api.g_ret_sts_unexp_error;

4645: logmessage(fnd_log.level_procedure, G_PKG_NAME, g_pkg_name || '.' || l_api_name || ' -');
4646:
4647: EXCEPTION
4648: WHEN others THEN
4649: x_return_status := fnd_api.g_ret_sts_unexp_error;
4650: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);
4651: END;
4652:
4653: