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_CUSTOM_PUB dependencies on FND_API

Line 123: IF FND_API.to_Boolean( p_init_msg_list ) THEN

119:
120: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, l_api_name || ' - BEGIN');
121:
122: -- Initialize message list IF p_init_msg_list is set to TRUE.
123: IF FND_API.to_Boolean( p_init_msg_list ) THEN
124: FND_MSG_PUB.initialize;
125: END IF;
126:
127: -- Initialize API return status to SUCCESS

Line 128: x_return_status := FND_API.G_RET_STS_SUCCESS;

124: FND_MSG_PUB.initialize;
125: END IF;
126:
127: -- Initialize API return status to SUCCESS
128: x_return_status := FND_API.G_RET_STS_SUCCESS;
129:
130: -- --------------------------------------------------------------------
131: -- Api body
132: -- --------------------------------------------------------------------

Line 143: if l_return_status <> FND_API.G_RET_STS_SUCCESS then

139: ,p_col_id => p_loan_id
140: ,p_col_name => 'LOAN_ID'
141: ,p_table_name => 'LNS_LOAN_HEADERS_ALL');
142:
143: if l_return_status <> FND_API.G_RET_STS_SUCCESS then
144: FND_MESSAGE.SET_NAME('LNS', 'LNS_INVALID_VALUE');
145: FND_MESSAGE.SET_TOKEN('PARAMETER', 'LOAN_ID');
146: FND_MESSAGE.SET_TOKEN('VALUE', p_loan_ID);
147: FND_MSG_PUB.ADD;

Line 148: RAISE FND_API.G_EXC_ERROR;

144: FND_MESSAGE.SET_NAME('LNS', 'LNS_INVALID_VALUE');
145: FND_MESSAGE.SET_TOKEN('PARAMETER', 'LOAN_ID');
146: FND_MESSAGE.SET_TOKEN('VALUE', p_loan_ID);
147: FND_MSG_PUB.ADD;
148: RAISE FND_API.G_EXC_ERROR;
149: end if;
150:
151: -- check to see if the loan is customized
152: open c_customized(p_loan_id);

Line 162: RAISE FND_API.G_EXC_ERROR;

158: l_skip_update := true;
159: /* dont raise this error as per karamach conversation 12-1-2004
160: FND_MESSAGE.Set_Name('LNS', 'LNS_NOT_CUSTOMIZED');
161: FND_MSG_PUB.Add;
162: RAISE FND_API.G_EXC_ERROR;
163: */
164: else
165: -- loan is customized
166: l_skip_update := false;

Line 175: RAISE FND_API.G_EXC_ERROR;

171:
172: if l_last_installment_billed > 0 then
173: FND_MESSAGE.Set_Name('LNS', 'LNS_LOAN_ALREADY_BILLED');
174: FND_MSG_PUB.Add;
175: RAISE FND_API.G_EXC_ERROR;
176: end if;
177:
178: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, l_api_name || ' - deleting custom rows');
179: delete

Line 192: lns_loan_header_pub.update_loan(p_init_msg_list => FND_API.G_FALSE

188: from lns_loan_headers_all
189: where loan_id = p_loan_id;
190: l_loan_header_rec.loan_id := p_loan_id;
191: l_loan_header_rec.custom_payments_flag := 'N';
192: lns_loan_header_pub.update_loan(p_init_msg_list => FND_API.G_FALSE
193: ,p_loan_header_rec => l_loan_header_rec
194: ,p_object_version_number => l_object_version
195: ,x_return_status => l_return_status
196: ,x_msg_count => l_msg_count

Line 207: IF FND_API.to_Boolean(p_commit) THEN

203: -- End of API body
204: -- --------------------------------------------------------------------
205:
206: -- Standard check for p_commit
207: IF FND_API.to_Boolean(p_commit) THEN
208: COMMIT WORK;
209: END IF;
210:
211: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);

Line 216: WHEN FND_API.G_EXC_ERROR THEN

212:
213: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, l_api_name || ' - END');
214:
215: EXCEPTION
216: WHEN FND_API.G_EXC_ERROR THEN
217: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
218: x_return_status := FND_API.G_RET_STS_ERROR;
219: x_msg_count := l_msg_count;
220: x_msg_data := l_msg_data;

Line 218: x_return_status := FND_API.G_RET_STS_ERROR;

214:
215: EXCEPTION
216: WHEN FND_API.G_EXC_ERROR THEN
217: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
218: x_return_status := FND_API.G_RET_STS_ERROR;
219: x_msg_count := l_msg_count;
220: x_msg_data := l_msg_data;
221: ROLLBACK TO resetCustomSchedule;
222: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);

Line 224: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN

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

Line 226: x_return_status := FND_API.G_RET_STS_ERROR;

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

Line 234: x_return_status := FND_API.G_RET_STS_ERROR;

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

Line 326: IF FND_API.to_Boolean( p_init_msg_list ) THEN

322: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, l_api_name || ' - rows received: ' || p_custom_tbl.count);
323: SAVEPOINT createCustomSchedule;
324:
325: -- Initialize message list IF p_init_msg_list is set to TRUE.
326: IF FND_API.to_Boolean( p_init_msg_list ) THEN
327: FND_MSG_PUB.initialize;
328: END IF;
329:
330: -- Initialize API return status to SUCCESS

Line 331: x_return_status := FND_API.G_RET_STS_SUCCESS;

327: FND_MSG_PUB.initialize;
328: END IF;
329:
330: -- Initialize API return status to SUCCESS
331: x_return_status := FND_API.G_RET_STS_SUCCESS;
332:
333: --
334: -- Api body
335: --

Line 355: if l_return_status <> FND_API.G_RET_STS_SUCCESS then

351: ,x_msg_count => l_msg_count
352: ,x_msg_data => l_msg_data);
353: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, l_api_name || ' - validateCustom ' || l_return_status);
354:
355: if l_return_status <> FND_API.G_RET_STS_SUCCESS then
356: if l_installment is not null then
357: X_INVALID_INSTALLMENT_NUM := l_installment;
358: FND_MESSAGE.Set_Name('LNS', 'LNS_INVALID_INSTALLMENT');
359: FND_MESSAGE.SET_TOKEN('PARAMETER', 'INSTALLMENT');

Line 362: RAISE FND_API.G_EXC_ERROR;

358: FND_MESSAGE.Set_Name('LNS', 'LNS_INVALID_INSTALLMENT');
359: FND_MESSAGE.SET_TOKEN('PARAMETER', 'INSTALLMENT');
360: FND_MESSAGE.SET_TOKEN('VALUE', l_installment);
361: FND_MSG_PUB.Add;
362: RAISE FND_API.G_EXC_ERROR;
363: end if;
364: FND_MESSAGE.Set_Name('LNS', 'LNS_VALIDATE_CUSTOM_ERROR');
365: FND_MSG_PUB.Add;
366: RAISE FND_API.G_EXC_ERROR;

Line 366: RAISE FND_API.G_EXC_ERROR;

362: RAISE FND_API.G_EXC_ERROR;
363: end if;
364: FND_MESSAGE.Set_Name('LNS', 'LNS_VALIDATE_CUSTOM_ERROR');
365: FND_MSG_PUB.Add;
366: RAISE FND_API.G_EXC_ERROR;
367: end if;
368:
369: open c_loan_details(p_loan_id);
370: fetch c_loan_details into l_loan_start_date, l_original_loan_amount;

Line 513: lns_loan_header_pub.update_loan(p_init_msg_list => FND_API.G_FALSE

509:
510: l_loan_header_rec.loan_id := p_loan_id;
511: l_loan_header_rec.CUSTOM_PAYMENTS_FLAG := 'Y';
512:
513: lns_loan_header_pub.update_loan(p_init_msg_list => FND_API.G_FALSE
514: ,p_loan_header_rec => l_loan_header_rec
515: ,P_OBJECT_VERSION_NUMBER => l_object_version
516: ,X_RETURN_STATUS => l_return_status
517: ,X_MSG_COUNT => l_msg_count

Line 524: if l_return_status <> FND_API.G_RET_STS_SUCCESS then

520: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, l_api_name || ' - l_msg_data ' || l_msg_data);
521:
522: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, l_api_name || ' - header update set custom = Y');
523:
524: if l_return_status <> FND_API.G_RET_STS_SUCCESS then
525: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, l_api_name || ' - header update ERROR');
526: FND_MESSAGE.Set_Name('LNS', 'LNS_HEADER_UPDATE_ERROR');
527: FND_MSG_PUB.Add;
528: RAISE FND_API.G_EXC_ERROR;

Line 528: RAISE FND_API.G_EXC_ERROR;

524: if l_return_status <> FND_API.G_RET_STS_SUCCESS then
525: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, l_api_name || ' - header update ERROR');
526: FND_MESSAGE.Set_Name('LNS', 'LNS_HEADER_UPDATE_ERROR');
527: FND_MSG_PUB.Add;
528: RAISE FND_API.G_EXC_ERROR;
529: end if;
530:
531: IF FND_API.to_Boolean(p_commit)
532: THEN

Line 531: IF FND_API.to_Boolean(p_commit)

527: FND_MSG_PUB.Add;
528: RAISE FND_API.G_EXC_ERROR;
529: end if;
530:
531: IF FND_API.to_Boolean(p_commit)
532: THEN
533: COMMIT WORK;
534: END IF;
535:

Line 542: WHEN FND_API.G_EXC_ERROR THEN

538:
539: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, l_api_name || ' - END');
540:
541: EXCEPTION
542: WHEN FND_API.G_EXC_ERROR THEN
543: FND_MESSAGE.Set_Name('LNS', 'LNS_CREATE_CUSTOM_ERROR');
544: FND_MSG_PUB.Add;
545: x_return_status := FND_API.G_RET_STS_ERROR;
546: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);

Line 545: x_return_status := FND_API.G_RET_STS_ERROR;

541: EXCEPTION
542: WHEN FND_API.G_EXC_ERROR THEN
543: FND_MESSAGE.Set_Name('LNS', 'LNS_CREATE_CUSTOM_ERROR');
544: FND_MSG_PUB.Add;
545: x_return_status := FND_API.G_RET_STS_ERROR;
546: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
547: ROLLBACK TO createCustomSchedule;
548:
549: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN

Line 549: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN

545: x_return_status := FND_API.G_RET_STS_ERROR;
546: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
547: ROLLBACK TO createCustomSchedule;
548:
549: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
550: FND_MESSAGE.Set_Name('LNS', 'LNS_CREATE_CUSTOM_ERROR');
551: FND_MSG_PUB.Add;
552: x_return_status := FND_API.G_RET_STS_ERROR;
553: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);

Line 552: x_return_status := FND_API.G_RET_STS_ERROR;

548:
549: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
550: FND_MESSAGE.Set_Name('LNS', 'LNS_CREATE_CUSTOM_ERROR');
551: FND_MSG_PUB.Add;
552: x_return_status := FND_API.G_RET_STS_ERROR;
553: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
554: ROLLBACK TO createCustomSchedule;
555:
556: WHEN OTHERS THEN

Line 559: x_return_status := FND_API.G_RET_STS_ERROR;

555:
556: WHEN OTHERS THEN
557: FND_MESSAGE.Set_Name('LNS', 'LNS_CREATE_CUSTOM_ERROR');
558: FND_MSG_PUB.Add;
559: x_return_status := FND_API.G_RET_STS_ERROR;
560: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
561: ROLLBACK TO createCustomSchedule;
562:
563: end;

Line 644: IF FND_API.to_Boolean( p_init_msg_list ) THEN

640: SAVEPOINT updateCustomSchedule;
641: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, l_api_name || ' - BEGIN');
642:
643: -- Initialize message list IF p_init_msg_list is set to TRUE.
644: IF FND_API.to_Boolean( p_init_msg_list ) THEN
645: FND_MSG_PUB.initialize;
646: END IF;
647:
648: -- Initialize API return status to SUCCESS

Line 649: x_return_status := FND_API.G_RET_STS_SUCCESS;

645: FND_MSG_PUB.initialize;
646: END IF;
647:
648: -- Initialize API return status to SUCCESS
649: x_return_status := FND_API.G_RET_STS_SUCCESS;
650:
651: --
652: -- Api body
653: --

Line 684: if l_return_status <> FND_API.G_RET_STS_SUCCESS then

680: ,x_return_status => l_return_status
681: ,x_msg_count => l_msg_count
682: ,x_msg_data => l_msg_data);
683:
684: if l_return_status <> FND_API.G_RET_STS_SUCCESS then
685: if l_installment is not null then
686: X_INVALID_INSTALLMENT_NUM := l_installment;
687: FND_MESSAGE.Set_Name('LNS', 'LNS_INVALID_INSTALLMENT');
688: FND_MESSAGE.SET_TOKEN('PARAMETER', 'INSTALLMENT');

Line 691: RAISE FND_API.G_EXC_ERROR;

687: FND_MESSAGE.Set_Name('LNS', 'LNS_INVALID_INSTALLMENT');
688: FND_MESSAGE.SET_TOKEN('PARAMETER', 'INSTALLMENT');
689: FND_MESSAGE.SET_TOKEN('VALUE', l_installment);
690: FND_MSG_PUB.Add;
691: RAISE FND_API.G_EXC_ERROR;
692: end if;
693: FND_MESSAGE.Set_Name('LNS', 'LNS_VALIDATE_CUSTOM_ERROR');
694: FND_MSG_PUB.Add;
695: RAISE FND_API.G_EXC_ERROR;

Line 695: RAISE FND_API.G_EXC_ERROR;

691: RAISE FND_API.G_EXC_ERROR;
692: end if;
693: FND_MESSAGE.Set_Name('LNS', 'LNS_VALIDATE_CUSTOM_ERROR');
694: FND_MSG_PUB.Add;
695: RAISE FND_API.G_EXC_ERROR;
696: end if;
697:
698: -- now we've passed validation initialize loan_begin_balance to calculate balances
699: l_custom_tbl2(1).installment_begin_balance := lns_financials.getRemainingBalance(p_loan_id);

Line 743: IF FND_API.to_Boolean(p_commit)

739: ,x_msg_data => l_msg_Data);
740:
741: end loop;
742:
743: IF FND_API.to_Boolean(p_commit)
744: THEN
745: COMMIT WORK;
746: END IF;
747:

Line 753: WHEN FND_API.G_EXC_ERROR THEN

749: p_data => x_msg_data);
750: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, l_api_name || ' - END');
751:
752: EXCEPTION
753: WHEN FND_API.G_EXC_ERROR THEN
754: --FND_MESSAGE.Set_Name('LNS', 'LNS_UPDATE_CUSTOM_ERROR');
755: --FND_MSG_PUB.Add;
756: --RAISE FND_API.G_EXC_ERROR;
757: x_return_status := FND_API.G_RET_STS_ERROR;

Line 756: --RAISE FND_API.G_EXC_ERROR;

752: EXCEPTION
753: WHEN FND_API.G_EXC_ERROR THEN
754: --FND_MESSAGE.Set_Name('LNS', 'LNS_UPDATE_CUSTOM_ERROR');
755: --FND_MSG_PUB.Add;
756: --RAISE FND_API.G_EXC_ERROR;
757: x_return_status := FND_API.G_RET_STS_ERROR;
758: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
759: ROLLBACK TO updateCustomSchedule;
760:

Line 757: x_return_status := FND_API.G_RET_STS_ERROR;

753: WHEN FND_API.G_EXC_ERROR THEN
754: --FND_MESSAGE.Set_Name('LNS', 'LNS_UPDATE_CUSTOM_ERROR');
755: --FND_MSG_PUB.Add;
756: --RAISE FND_API.G_EXC_ERROR;
757: x_return_status := FND_API.G_RET_STS_ERROR;
758: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
759: ROLLBACK TO updateCustomSchedule;
760:
761: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN

Line 761: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN

757: x_return_status := FND_API.G_RET_STS_ERROR;
758: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
759: ROLLBACK TO updateCustomSchedule;
760:
761: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
762: --FND_MESSAGE.Set_Name('LNS', 'LNS_UPDATE_CUSTOM_ERROR');
763: --FND_MSG_PUB.Add;
764: --RAISE FND_API.G_EXC_ERROR;
765: x_return_status := FND_API.G_RET_STS_ERROR;

Line 764: --RAISE FND_API.G_EXC_ERROR;

760:
761: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
762: --FND_MESSAGE.Set_Name('LNS', 'LNS_UPDATE_CUSTOM_ERROR');
763: --FND_MSG_PUB.Add;
764: --RAISE FND_API.G_EXC_ERROR;
765: x_return_status := FND_API.G_RET_STS_ERROR;
766: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
767: ROLLBACK TO updateCustomSchedule;
768:

Line 765: x_return_status := FND_API.G_RET_STS_ERROR;

761: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
762: --FND_MESSAGE.Set_Name('LNS', 'LNS_UPDATE_CUSTOM_ERROR');
763: --FND_MSG_PUB.Add;
764: --RAISE FND_API.G_EXC_ERROR;
765: x_return_status := FND_API.G_RET_STS_ERROR;
766: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
767: ROLLBACK TO updateCustomSchedule;
768:
769: WHEN OTHERS THEN

Line 772: --RAISE FND_API.G_EXC_ERROR;

768:
769: WHEN OTHERS THEN
770: --FND_MESSAGE.Set_Name('LNS', 'LNS_UPDATE_CUSTOM_ERROR');
771: --FND_MSG_PUB.Add;
772: --RAISE FND_API.G_EXC_ERROR;
773: x_return_status := FND_API.G_RET_STS_ERROR;
774: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
775: ROLLBACK TO updateCustomSchedule;
776:

Line 773: x_return_status := FND_API.G_RET_STS_ERROR;

769: WHEN OTHERS THEN
770: --FND_MESSAGE.Set_Name('LNS', 'LNS_UPDATE_CUSTOM_ERROR');
771: --FND_MSG_PUB.Add;
772: --RAISE FND_API.G_EXC_ERROR;
773: x_return_status := FND_API.G_RET_STS_ERROR;
774: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
775: ROLLBACK TO updateCustomSchedule;
776:
777: end;

Line 843: RAISE FND_API.G_EXC_ERROR;

839:
840: if l_loan_details.number_installments - l_count <> l_cust_tbl.count then
841: FND_MESSAGE.Set_Name('LNS', 'LNS_INVALID_NUM_ROWS');
842: FND_MSG_PUB.Add;
843: RAISE FND_API.G_EXC_ERROR;
844: end if;
845: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, 'passed update validation');
846: end if;
847:

Line 861: RAISE FND_API.G_EXC_ERROR;

857: if l_cust_tbl(1).installment_begin_balance <> lns_financials.getRemainingBalance(p_loan_id) then
858: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, 'balance incorrect');
859: FND_MESSAGE.Set_Name('LNS', 'LNS_BEGIN_BALANCE_INCORRECT');
860: FND_MSG_PUB.Add;
861: RAISE FND_API.G_EXC_ERROR;
862: end if;
863: end if;
864: */
865: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, 'validate custom row');

Line 871: if l_return_status <> FND_API.G_RET_STS_SUCCESS then

867: ,x_return_status => l_return_status
868: ,x_msg_count => l_msg_count
869: ,x_msg_data => l_msg_data);
870:
871: if l_return_status <> FND_API.G_RET_STS_SUCCESS then
872: x_installment := i;
873: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, 'invalid installment found #' || i);
874: FND_MESSAGE.Set_Name('LNS', 'LNS_INVALID_INSTALLMENT');
875: FND_MESSAGE.SET_TOKEN('PARAMETER', 'INSTALLMENT');

Line 878: RAISE FND_API.G_EXC_ERROR;

874: FND_MESSAGE.Set_Name('LNS', 'LNS_INVALID_INSTALLMENT');
875: FND_MESSAGE.SET_TOKEN('PARAMETER', 'INSTALLMENT');
876: FND_MESSAGE.SET_TOKEN('VALUE', i);
877: FND_MSG_PUB.Add;
878: RAISE FND_API.G_EXC_ERROR;
879: end if;
880:
881: -- check for consecutive installments
882: if l_cust_tbl.exists(i+1) then

Line 887: RAISE FND_API.G_EXC_ERROR;

883: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, 'checking consecutive installments' || l_cust_tbl(i).payment_number || ' ' || l_cust_tbl(i+1).payment_number );
884: if l_cust_tbl(i).payment_number + 1 <> l_cust_tbl(i+1).payment_number then
885: FND_MESSAGE.Set_Name('LNS', 'LNS_NONSEQUENTIAL_INSTALLMENTS');
886: FND_MSG_PUB.Add;
887: RAISE FND_API.G_EXC_ERROR;
888: end if;
889: end if;
890:
891: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, 'date checking');

Line 903: RAISE FND_API.G_EXC_ERROR;

899: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, 'l_date is: ' || l_date);
900: if p_cust_tbl(i).due_date <= l_date then
901: FND_MESSAGE.Set_Name('LNS', 'LNS_NONSEQUENTIAL_DATES');
902: FND_MSG_PUB.Add;
903: RAISE FND_API.G_EXC_ERROR;
904: end if;
905: l_date := l_cust_tbl(i).due_date;
906:
907: end if;

Line 922: RAISE FND_API.G_EXC_ERROR;

918: if l_amount <> l_loan_details.remaining_balance then
919: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, 'balance check incorrect');
920: FND_MESSAGE.Set_Name('LNS', 'LNS_BALANCE_INCORRECT');
921: FND_MSG_PUB.Add;
922: RAISE FND_API.G_EXC_ERROR;
923: end if;
924:
925: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, 'after final balance check');
926: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);

Line 932: WHEN FND_API.G_EXC_ERROR THEN

928: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, l_api_name || ' - END');
929:
930: EXCEPTION
931:
932: WHEN FND_API.G_EXC_ERROR THEN
933: --FND_MESSAGE.Set_Name('LNS', 'LNS_VALIDATE_CUSTOM_ERROR');
934: --FND_MSG_PUB.Add;
935: x_return_status := FND_API.G_RET_STS_ERROR;
936: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);

Line 935: x_return_status := FND_API.G_RET_STS_ERROR;

931:
932: WHEN FND_API.G_EXC_ERROR THEN
933: --FND_MESSAGE.Set_Name('LNS', 'LNS_VALIDATE_CUSTOM_ERROR');
934: --FND_MSG_PUB.Add;
935: x_return_status := FND_API.G_RET_STS_ERROR;
936: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
937:
938: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
939: --FND_MESSAGE.Set_Name('LNS', 'LNS_VALIDATE_CUSTOM_ERROR');

Line 938: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN

934: --FND_MSG_PUB.Add;
935: x_return_status := FND_API.G_RET_STS_ERROR;
936: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
937:
938: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
939: --FND_MESSAGE.Set_Name('LNS', 'LNS_VALIDATE_CUSTOM_ERROR');
940: --FND_MSG_PUB.Add;
941: x_return_status := FND_API.G_RET_STS_ERROR;
942: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);

Line 941: x_return_status := FND_API.G_RET_STS_ERROR;

937:
938: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
939: --FND_MESSAGE.Set_Name('LNS', 'LNS_VALIDATE_CUSTOM_ERROR');
940: --FND_MSG_PUB.Add;
941: x_return_status := FND_API.G_RET_STS_ERROR;
942: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
943:
944: WHEN OTHERS THEN
945: --FND_MESSAGE.Set_Name('LNS', 'LNS_VALIDATE_CUSTOM_ERROR');

Line 947: x_return_status := FND_API.G_RET_STS_ERROR;

943:
944: WHEN OTHERS THEN
945: --FND_MESSAGE.Set_Name('LNS', 'LNS_VALIDATE_CUSTOM_ERROR');
946: --FND_MSG_PUB.Add;
947: x_return_status := FND_API.G_RET_STS_ERROR;
948: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
949: End;
950:
951: /* procedure to validate a row in the LNS_CUSTOM_PAYMENT_SCHEDULE

Line 969: x_return_status := FND_API.G_RET_STS_SUCCESS;

965: l_api_name varchar2(30);
966:
967: BEGIN
968:
969: x_return_status := FND_API.G_RET_STS_SUCCESS;
970: l_api_name := 'validateCustRow';
971: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, l_api_name || ' validate One Row');
972: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, l_api_name || ' ' || p_custom_rec.PAYMENT_NUMBER );
973: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, l_api_name || ' ' || p_custom_rec.DUE_DATE );

Line 980: RAISE FND_API.G_EXC_ERROR;

976:
977: if p_custom_rec.due_Date is null then
978: FND_MESSAGE.Set_Name('LNS', 'LNS_NO_DUE_DATE');
979: FND_MSG_PUB.Add;
980: RAISE FND_API.G_EXC_ERROR;
981:
982: elsif p_custom_rec.payment_number is null or p_custom_rec.payment_number < 1 then
983: FND_MESSAGE.Set_Name('LNS', 'LNS_INVALID_PAYMENT_NUMBER');
984: FND_MSG_PUB.Add;

Line 985: RAISE FND_API.G_EXC_ERROR;

981:
982: elsif p_custom_rec.payment_number is null or p_custom_rec.payment_number < 1 then
983: FND_MESSAGE.Set_Name('LNS', 'LNS_INVALID_PAYMENT_NUMBER');
984: FND_MSG_PUB.Add;
985: RAISE FND_API.G_EXC_ERROR;
986:
987: elsif p_custom_rec.PRINCIPAL_AMOUNT is not null and p_custom_rec.PRINCIPAL_AMOUNT < 0 then
988: FND_MESSAGE.Set_Name('LNS', 'LNS_PRINICIPAL_AMOUNT_ERROR');
989: FND_MSG_PUB.Add;

Line 990: RAISE FND_API.G_EXC_ERROR;

986:
987: elsif p_custom_rec.PRINCIPAL_AMOUNT is not null and p_custom_rec.PRINCIPAL_AMOUNT < 0 then
988: FND_MESSAGE.Set_Name('LNS', 'LNS_PRINICIPAL_AMOUNT_ERROR');
989: FND_MSG_PUB.Add;
990: RAISE FND_API.G_EXC_ERROR;
991:
992: elsif p_custom_rec.INTEREST_AMOUNT is not null and p_custom_rec.INTEREST_AMOUNT < 0 then
993: FND_MESSAGE.Set_Name('LNS', 'LNS_INTEREST_AMOUNT_ERROR');
994: FND_MSG_PUB.Add;

Line 995: RAISE FND_API.G_EXC_ERROR;

991:
992: elsif p_custom_rec.INTEREST_AMOUNT is not null and p_custom_rec.INTEREST_AMOUNT < 0 then
993: FND_MESSAGE.Set_Name('LNS', 'LNS_INTEREST_AMOUNT_ERROR');
994: FND_MSG_PUB.Add;
995: RAISE FND_API.G_EXC_ERROR;
996:
997: elsif p_custom_rec.FEE_AMOUNT is not null and p_custom_rec.FEE_AMOUNT < 0 then
998: FND_MESSAGE.Set_Name('LNS', 'LNS_OTHER_AMOUNT_ERROR');
999: FND_MSG_PUB.Add;

Line 1000: RAISE FND_API.G_EXC_ERROR;

996:
997: elsif p_custom_rec.FEE_AMOUNT is not null and p_custom_rec.FEE_AMOUNT < 0 then
998: FND_MESSAGE.Set_Name('LNS', 'LNS_OTHER_AMOUNT_ERROR');
999: FND_MSG_PUB.Add;
1000: RAISE FND_API.G_EXC_ERROR;
1001:
1002: elsif p_custom_rec.OTHER_AMOUNT is not null and p_custom_rec.OTHER_AMOUNT < 0 then
1003: FND_MESSAGE.Set_Name('LNS', 'LNS_OTHER_AMOUNT_ERROR');
1004: FND_MSG_PUB.Add;

Line 1005: RAISE FND_API.G_EXC_ERROR;

1001:
1002: elsif p_custom_rec.OTHER_AMOUNT is not null and p_custom_rec.OTHER_AMOUNT < 0 then
1003: FND_MESSAGE.Set_Name('LNS', 'LNS_OTHER_AMOUNT_ERROR');
1004: FND_MSG_PUB.Add;
1005: RAISE FND_API.G_EXC_ERROR;
1006:
1007: end if;
1008:
1009: EXCEPTION

Line 1011: WHEN FND_API.G_EXC_ERROR THEN

1007: end if;
1008:
1009: EXCEPTION
1010:
1011: WHEN FND_API.G_EXC_ERROR THEN
1012: x_return_status := FND_API.G_RET_STS_ERROR;
1013: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
1014:
1015: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN

Line 1012: x_return_status := FND_API.G_RET_STS_ERROR;

1008:
1009: EXCEPTION
1010:
1011: WHEN FND_API.G_EXC_ERROR THEN
1012: x_return_status := FND_API.G_RET_STS_ERROR;
1013: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
1014:
1015: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
1016: x_return_status := FND_API.G_RET_STS_ERROR;

Line 1015: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN

1011: WHEN FND_API.G_EXC_ERROR THEN
1012: x_return_status := FND_API.G_RET_STS_ERROR;
1013: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
1014:
1015: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
1016: x_return_status := FND_API.G_RET_STS_ERROR;
1017: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
1018:
1019: WHEN OTHERS THEN

Line 1016: x_return_status := FND_API.G_RET_STS_ERROR;

1012: x_return_status := FND_API.G_RET_STS_ERROR;
1013: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
1014:
1015: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
1016: x_return_status := FND_API.G_RET_STS_ERROR;
1017: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
1018:
1019: WHEN OTHERS THEN
1020: x_return_status := FND_API.G_RET_STS_ERROR;

Line 1020: x_return_status := FND_API.G_RET_STS_ERROR;

1016: x_return_status := FND_API.G_RET_STS_ERROR;
1017: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
1018:
1019: WHEN OTHERS THEN
1020: x_return_status := FND_API.G_RET_STS_ERROR;
1021: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
1022:
1023: END validateCustomRow;
1024:

Line 1081: x_return_status := FND_API.G_RET_STS_SUCCESS;

1077: ,p_LOCK_INT => P_CUSTOM_REC.LOCK_INT
1078: ,p_PRINCIPAL_PERCENT => P_CUSTOM_REC.PRINCIPAL_PERCENT);
1079:
1080: x_custom_sched_id := l_custom_id;
1081: x_return_status := FND_API.G_RET_STS_SUCCESS;
1082:
1083: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, 'In createCustomSched: After call Insert_Row ID' || l_Custom_id );
1084:
1085: END createCustomSched;

Line 1150: x_return_status := FND_API.G_RET_STS_SUCCESS;

1146: ,p_LOCK_PRIN => P_CUSTOM_REC.LOCK_PRIN
1147: ,p_LOCK_INT => P_CUSTOM_REC.LOCK_INT
1148: ,p_PRINCIPAL_PERCENT => P_CUSTOM_REC.PRINCIPAL_PERCENT);
1149:
1150: x_return_status := FND_API.G_RET_STS_SUCCESS;
1151:
1152: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, 'In updateCustomSched: After call Insert_Row');
1153:
1154: END updateCustomSched;

Line 1198: RAISE FND_API.G_EXC_ERROR;

1194: -- LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'ERROR: Several installments have the same due date.');
1195: FND_MESSAGE.SET_NAME('LNS', 'LNS_DUE_DATE_DUPL');
1196: FND_MSG_PUB.Add;
1197: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
1198: RAISE FND_API.G_EXC_ERROR;
1199: */
1200: end if;
1201: end loop;
1202: end loop;

Line 1320: RAISE FND_API.G_EXC_ERROR;

1316: FND_MESSAGE.SET_NAME('LNS', 'LNS_INVALID_VALUE');
1317: FND_MESSAGE.SET_TOKEN('PARAMETER', 'RELATIVE_DATE');
1318: FND_MESSAGE.SET_TOKEN('VALUE', l_custom_tbl(i).RELATIVE_DATE);
1319: FND_MSG_PUB.ADD;
1320: RAISE FND_API.G_EXC_ERROR;
1321: END;
1322: /*
1323: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'RELATIVE_DATE = ' || l_custom_tbl(i).RELATIVE_DATE);
1324: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'l_term = ' || l_term);

Line 1339: RAISE FND_API.G_EXC_ERROR;

1335: FND_MESSAGE.SET_NAME('LNS', 'LNS_INVALID_VALUE');
1336: FND_MESSAGE.SET_TOKEN('PARAMETER', 'RELATIVE_DATE');
1337: FND_MESSAGE.SET_TOKEN('VALUE', l_custom_tbl(i).RELATIVE_DATE);
1338: FND_MSG_PUB.ADD;
1339: RAISE FND_API.G_EXC_ERROR;
1340: end if;
1341: */
1342: end if;
1343: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'DUE_DATE = ' || l_custom_tbl(i).DUE_DATE);

Line 1350: RAISE FND_API.G_EXC_ERROR;

1346:
1347: if l_custom_tbl(i).DUE_DATE is null then
1348: FND_MESSAGE.Set_Name('LNS', 'LNS_NO_DUE_DATE');
1349: FND_MSG_PUB.Add;
1350: RAISE FND_API.G_EXC_ERROR;
1351: end if;
1352:
1353: if l_custom_tbl(i).DUE_DATE < p_loan_details.loan_start_date or
1354: (p_loan_details.LAST_DUE_DATE is not null and l_custom_tbl(i).DUE_DATE <= p_loan_details.LAST_DUE_DATE) or

Line 1787: RAISE FND_API.G_EXC_ERROR;

1783: When No_Data_Found then
1784: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, 'LOAN ID: ' || p_loan_id || ' not found');
1785: FND_MESSAGE.Set_Name('LNS', 'LNS_INVALID_LOAN_ID');
1786: FND_MSG_PUB.Add;
1787: RAISE FND_API.G_EXC_ERROR;
1788:
1789: When Others then
1790: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, 'Err: ' || sqlerrm);
1791: RAISE FND_API.G_EXC_ERROR;

Line 1791: RAISE FND_API.G_EXC_ERROR;

1787: RAISE FND_API.G_EXC_ERROR;
1788:
1789: When Others then
1790: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, 'Err: ' || sqlerrm);
1791: RAISE FND_API.G_EXC_ERROR;
1792:
1793: end getLoanDetails;
1794:
1795:

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

1859: SAVEPOINT loadCustomSchedule;
1860: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Savepoint is established');
1861:
1862: -- Standard call to check for call compatibility
1863: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version, l_api_name, G_PKG_NAME) THEN
1864: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
1865: END IF;
1866:
1867: -- Initialize message list if p_init_msg_list is set to TRUE

Line 1864: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;

1860: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Savepoint is established');
1861:
1862: -- Standard call to check for call compatibility
1863: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version, l_api_name, G_PKG_NAME) THEN
1864: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
1865: END IF;
1866:
1867: -- Initialize message list if p_init_msg_list is set to TRUE
1868: IF FND_API.To_Boolean(p_init_msg_list) THEN

Line 1868: IF FND_API.To_Boolean(p_init_msg_list) THEN

1864: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
1865: END IF;
1866:
1867: -- Initialize message list if p_init_msg_list is set to TRUE
1868: IF FND_API.To_Boolean(p_init_msg_list) THEN
1869: FND_MSG_PUB.initialize;
1870: END IF;
1871:
1872: -- Initialize API return status to success

Line 1873: l_return_status := FND_API.G_RET_STS_SUCCESS;

1869: FND_MSG_PUB.initialize;
1870: END IF;
1871:
1872: -- Initialize API return status to success
1873: l_return_status := FND_API.G_RET_STS_SUCCESS;
1874:
1875: -- START OF BODY OF API
1876:
1877: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Input:');

Line 1886: RAISE FND_API.G_EXC_ERROR;

1882: FND_MESSAGE.SET_NAME('LNS', 'LNS_INVALID_VALUE');
1883: FND_MESSAGE.SET_TOKEN('PARAMETER', 'LOAN_ID');
1884: FND_MESSAGE.SET_TOKEN('VALUE', P_LOAN_ID);
1885: FND_MSG_PUB.ADD;
1886: RAISE FND_API.G_EXC_ERROR;
1887: end if;
1888:
1889: if P_BASED_ON_TERMS is null then
1890: FND_MESSAGE.SET_NAME('LNS', 'LNS_INVALID_VALUE');

Line 1894: RAISE FND_API.G_EXC_ERROR;

1890: FND_MESSAGE.SET_NAME('LNS', 'LNS_INVALID_VALUE');
1891: FND_MESSAGE.SET_TOKEN('PARAMETER', 'BASED_ON_TERMS');
1892: FND_MESSAGE.SET_TOKEN('VALUE', P_BASED_ON_TERMS);
1893: FND_MSG_PUB.ADD;
1894: RAISE FND_API.G_EXC_ERROR;
1895: end if;
1896:
1897: l_loan_details := getLoanDetails(p_loan_Id => p_loan_id
1898: ,p_based_on_terms => p_based_on_terms);

Line 1908: P_INIT_MSG_LIST => FND_API.G_TRUE,

1904:
1905: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Calling LNS_FINANCIALS.runAmortization...');
1906: LNS_FINANCIALS.runAmortization(
1907: P_API_VERSION => 1.0,
1908: P_INIT_MSG_LIST => FND_API.G_TRUE,
1909: P_COMMIT => FND_API.G_FALSE,
1910: P_LOAN_ID => P_LOAN_ID,
1911: P_BASED_ON_TERMS => P_BASED_ON_TERMS,
1912: x_amort_tbl => l_amort_tbl,

Line 1909: P_COMMIT => FND_API.G_FALSE,

1905: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Calling LNS_FINANCIALS.runAmortization...');
1906: LNS_FINANCIALS.runAmortization(
1907: P_API_VERSION => 1.0,
1908: P_INIT_MSG_LIST => FND_API.G_TRUE,
1909: P_COMMIT => FND_API.G_FALSE,
1910: P_LOAN_ID => P_LOAN_ID,
1911: P_BASED_ON_TERMS => P_BASED_ON_TERMS,
1912: x_amort_tbl => l_amort_tbl,
1913: x_return_status => l_return_status,

Line 1918: RAISE FND_API.G_EXC_ERROR;

1914: x_msg_count => l_msg_count,
1915: x_msg_data => l_msg_data);
1916:
1917: IF l_return_status <> 'S' THEN
1918: RAISE FND_API.G_EXC_ERROR;
1919: END IF;
1920:
1921: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Schedule from LNS_FINANCIALS.runAmortization:');
1922: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'PN DD PRIN LP INT LI FEE OTH ID');

Line 2026: P_INIT_MSG_LIST => FND_API.G_TRUE,

2022:
2023: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Recalculating schedule...');
2024: LNS_CUSTOM_PUB.recalcCustomSchedule(
2025: P_API_VERSION => 1.0,
2026: P_INIT_MSG_LIST => FND_API.G_TRUE,
2027: P_COMMIT => FND_API.G_FALSE,
2028: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,
2029: P_LOAN_ID => P_LOAN_ID,
2030: P_BASED_ON_TERMS => P_BASED_ON_TERMS,

Line 2027: P_COMMIT => FND_API.G_FALSE,

2023: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Recalculating schedule...');
2024: LNS_CUSTOM_PUB.recalcCustomSchedule(
2025: P_API_VERSION => 1.0,
2026: P_INIT_MSG_LIST => FND_API.G_TRUE,
2027: P_COMMIT => FND_API.G_FALSE,
2028: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,
2029: P_LOAN_ID => P_LOAN_ID,
2030: P_BASED_ON_TERMS => P_BASED_ON_TERMS,
2031: P_USE_RETAINED_DATA => 'N',

Line 2028: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,

2024: LNS_CUSTOM_PUB.recalcCustomSchedule(
2025: P_API_VERSION => 1.0,
2026: P_INIT_MSG_LIST => FND_API.G_TRUE,
2027: P_COMMIT => FND_API.G_FALSE,
2028: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,
2029: P_LOAN_ID => P_LOAN_ID,
2030: P_BASED_ON_TERMS => P_BASED_ON_TERMS,
2031: P_USE_RETAINED_DATA => 'N',
2032: P_CUSTOM_SET_REC => l_CUSTOM_SET_REC,

Line 2039: RAISE FND_API.G_EXC_ERROR;

2035: x_msg_count => l_msg_count,
2036: x_msg_data => l_msg_data);
2037:
2038: IF l_return_status <> 'S' THEN
2039: RAISE FND_API.G_EXC_ERROR;
2040: END IF;
2041:
2042: if P_COMMIT = FND_API.G_TRUE then
2043: COMMIT WORK;

Line 2042: if P_COMMIT = FND_API.G_TRUE then

2038: IF l_return_status <> 'S' THEN
2039: RAISE FND_API.G_EXC_ERROR;
2040: END IF;
2041:
2042: if P_COMMIT = FND_API.G_TRUE then
2043: COMMIT WORK;
2044: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Commited');
2045: end if;
2046:

Line 2051: x_return_status := FND_API.G_RET_STS_SUCCESS;

2047: X_CUSTOM_TBL := l_CUSTOM_TBL;
2048: X_CUSTOM_SET_REC := l_CUSTOM_SET_REC;
2049:
2050: -- END OF BODY OF API
2051: x_return_status := FND_API.G_RET_STS_SUCCESS;
2052:
2053: -- Standard call to get message count and if count is 1, get message info
2054: FND_MSG_PUB.Count_And_Get(
2055: p_encoded => FND_API.G_FALSE,

Line 2055: p_encoded => FND_API.G_FALSE,

2051: x_return_status := FND_API.G_RET_STS_SUCCESS;
2052:
2053: -- Standard call to get message count and if count is 1, get message info
2054: FND_MSG_PUB.Count_And_Get(
2055: p_encoded => FND_API.G_FALSE,
2056: p_count => x_msg_count,
2057: p_data => x_msg_data);
2058:
2059: LogMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, G_PKG_NAME || '.' || l_api_name || ' -');

Line 2062: WHEN FND_API.G_EXC_ERROR THEN

2058:
2059: LogMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, G_PKG_NAME || '.' || l_api_name || ' -');
2060:
2061: EXCEPTION
2062: WHEN FND_API.G_EXC_ERROR THEN
2063: ROLLBACK TO loadCustomSchedule;
2064: x_return_status := FND_API.G_RET_STS_ERROR;
2065: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
2066: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');

Line 2064: x_return_status := FND_API.G_RET_STS_ERROR;

2060:
2061: EXCEPTION
2062: WHEN FND_API.G_EXC_ERROR THEN
2063: ROLLBACK TO loadCustomSchedule;
2064: x_return_status := FND_API.G_RET_STS_ERROR;
2065: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
2066: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');
2067: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
2068: ROLLBACK TO loadCustomSchedule;

Line 2067: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN

2063: ROLLBACK TO loadCustomSchedule;
2064: x_return_status := FND_API.G_RET_STS_ERROR;
2065: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
2066: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');
2067: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
2068: ROLLBACK TO loadCustomSchedule;
2069: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
2070: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
2071: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');

Line 2069: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;

2065: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
2066: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');
2067: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
2068: ROLLBACK TO loadCustomSchedule;
2069: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
2070: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
2071: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');
2072: WHEN OTHERS THEN
2073: ROLLBACK TO loadCustomSchedule;

Line 2074: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;

2070: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
2071: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');
2072: WHEN OTHERS THEN
2073: ROLLBACK TO loadCustomSchedule;
2074: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
2075: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
2076: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');
2077: END;
2078:

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

2249: SAVEPOINT recalcCustomSchedule;
2250: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Savepoint is established');
2251:
2252: -- Standard call to check for call compatibility
2253: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version, l_api_name, G_PKG_NAME) THEN
2254: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
2255: END IF;
2256:
2257: -- Initialize message list if p_init_msg_list is set to TRUE

Line 2254: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;

2250: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Savepoint is established');
2251:
2252: -- Standard call to check for call compatibility
2253: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version, l_api_name, G_PKG_NAME) THEN
2254: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
2255: END IF;
2256:
2257: -- Initialize message list if p_init_msg_list is set to TRUE
2258: IF FND_API.To_Boolean(p_init_msg_list) THEN

Line 2258: IF FND_API.To_Boolean(p_init_msg_list) THEN

2254: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
2255: END IF;
2256:
2257: -- Initialize message list if p_init_msg_list is set to TRUE
2258: IF FND_API.To_Boolean(p_init_msg_list) THEN
2259: FND_MSG_PUB.initialize;
2260: END IF;
2261:
2262: -- Initialize API return status to success

Line 2263: l_return_status := FND_API.G_RET_STS_SUCCESS;

2259: FND_MSG_PUB.initialize;
2260: END IF;
2261:
2262: -- Initialize API return status to success
2263: l_return_status := FND_API.G_RET_STS_SUCCESS;
2264:
2265: -- START OF BODY OF API
2266:
2267: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Input:');

Line 2279: RAISE FND_API.G_EXC_ERROR;

2275: FND_MESSAGE.SET_NAME('LNS', 'LNS_INVALID_VALUE');
2276: FND_MESSAGE.SET_TOKEN('PARAMETER', 'LOAN_ID');
2277: FND_MESSAGE.SET_TOKEN('VALUE', P_LOAN_ID);
2278: FND_MSG_PUB.ADD;
2279: RAISE FND_API.G_EXC_ERROR;
2280: end if;
2281:
2282: if P_BASED_ON_TERMS is null then
2283: FND_MESSAGE.SET_NAME('LNS', 'LNS_INVALID_VALUE');

Line 2287: RAISE FND_API.G_EXC_ERROR;

2283: FND_MESSAGE.SET_NAME('LNS', 'LNS_INVALID_VALUE');
2284: FND_MESSAGE.SET_TOKEN('PARAMETER', 'BASED_ON_TERMS');
2285: FND_MESSAGE.SET_TOKEN('VALUE', P_BASED_ON_TERMS);
2286: FND_MSG_PUB.ADD;
2287: RAISE FND_API.G_EXC_ERROR;
2288: end if;
2289:
2290: if P_USE_RETAINED_DATA is not null and P_USE_RETAINED_DATA = 'Y' then
2291: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'count = ' || G_CUSTOM_TBL.count);

Line 2349: x_return_status := FND_API.G_RET_STS_SUCCESS;

2345: resolveRelativeDates(l_loan_details, l_custom_tbl);
2346: if l_custom_tbl.count = 0 then
2347:
2348: -- fix for bug 7217204
2349: x_return_status := FND_API.G_RET_STS_SUCCESS;
2350: P_CUSTOM_TBL := l_CUSTOM_TBL;
2351: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Custom schedule is empty. Returning.');
2352: return;
2353:

Line 3327: LNS_FEE_ENGINE.getFeeDetails(p_init_msg_list => FND_API.G_FALSE

3323: l_fee_basis_tbl(9).fee_basis_name := 'CURR_LOAN';
3324: l_fee_basis_tbl(9).fee_basis_amount := l_loan_details.requested_amount + l_loan_details.ADD_REQUESTED_AMOUNT;
3325:
3326: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, l_api_name || ': Calling LNS_FEE_ENGINE.getFeeDetails for this installment...');
3327: LNS_FEE_ENGINE.getFeeDetails(p_init_msg_list => FND_API.G_FALSE
3328: ,p_loan_id => p_loan_id
3329: ,p_installment => l_custom_tbl(i).PAYMENT_NUMBER
3330: ,p_fee_basis_tbl => l_fee_basis_tbl
3331: ,p_based_on_terms => p_based_on_terms

Line 3340: RAISE FND_API.G_EXC_ERROR;

3336: ,x_msg_data => l_msg_data);
3337:
3338: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, l_api_name || ': l_return_status = ' || l_return_status);
3339: if l_return_status <> 'S' then
3340: RAISE FND_API.G_EXC_ERROR;
3341: end if;
3342:
3343: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, l_api_name || ': l_fees_tbl.count = ' || l_fees_tbl.count);
3344:

Line 3444: if P_COMMIT = FND_API.G_TRUE then

3440: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Output Settings:');
3441: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'AMORT_METHOD = ' || P_CUSTOM_SET_REC.AMORT_METHOD);
3442: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'DESCRIPTION = ' || P_CUSTOM_SET_REC.DESCRIPTION);
3443:
3444: if P_COMMIT = FND_API.G_TRUE then
3445: COMMIT WORK;
3446: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Commited');
3447: end if;
3448:

Line 3450: x_return_status := FND_API.G_RET_STS_SUCCESS;

3446: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Commited');
3447: end if;
3448:
3449: -- END OF BODY OF API
3450: x_return_status := FND_API.G_RET_STS_SUCCESS;
3451:
3452: -- Standard call to get message count and if count is 1, get message info
3453: FND_MSG_PUB.Count_And_Get(
3454: p_encoded => FND_API.G_FALSE,

Line 3454: p_encoded => FND_API.G_FALSE,

3450: x_return_status := FND_API.G_RET_STS_SUCCESS;
3451:
3452: -- Standard call to get message count and if count is 1, get message info
3453: FND_MSG_PUB.Count_And_Get(
3454: p_encoded => FND_API.G_FALSE,
3455: p_count => x_msg_count,
3456: p_data => x_msg_data);
3457:
3458: LogMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, G_PKG_NAME || '.' || l_api_name || ' -');

Line 3461: WHEN FND_API.G_EXC_ERROR THEN

3457:
3458: LogMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, G_PKG_NAME || '.' || l_api_name || ' -');
3459:
3460: EXCEPTION
3461: WHEN FND_API.G_EXC_ERROR THEN
3462: ROLLBACK TO recalcCustomSchedule;
3463: x_return_status := FND_API.G_RET_STS_ERROR;
3464: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
3465: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');

Line 3463: x_return_status := FND_API.G_RET_STS_ERROR;

3459:
3460: EXCEPTION
3461: WHEN FND_API.G_EXC_ERROR THEN
3462: ROLLBACK TO recalcCustomSchedule;
3463: x_return_status := FND_API.G_RET_STS_ERROR;
3464: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
3465: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');
3466: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
3467: ROLLBACK TO recalcCustomSchedule;

Line 3466: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN

3462: ROLLBACK TO recalcCustomSchedule;
3463: x_return_status := FND_API.G_RET_STS_ERROR;
3464: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
3465: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');
3466: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
3467: ROLLBACK TO recalcCustomSchedule;
3468: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
3469: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
3470: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');

Line 3468: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;

3464: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
3465: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');
3466: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
3467: ROLLBACK TO recalcCustomSchedule;
3468: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
3469: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
3470: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');
3471: WHEN OTHERS THEN
3472: ROLLBACK TO recalcCustomSchedule;

Line 3473: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;

3469: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
3470: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');
3471: WHEN OTHERS THEN
3472: ROLLBACK TO recalcCustomSchedule;
3473: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
3474: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
3475: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');
3476: END;
3477:

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

3545: SAVEPOINT saveCustomSchedule;
3546: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Savepoint is established');
3547:
3548: -- Standard call to check for call compatibility
3549: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version, l_api_name, G_PKG_NAME) THEN
3550: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
3551: END IF;
3552:
3553: -- Initialize message list if p_init_msg_list is set to TRUE

Line 3550: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;

3546: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Savepoint is established');
3547:
3548: -- Standard call to check for call compatibility
3549: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version, l_api_name, G_PKG_NAME) THEN
3550: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
3551: END IF;
3552:
3553: -- Initialize message list if p_init_msg_list is set to TRUE
3554: IF FND_API.To_Boolean(p_init_msg_list) THEN

Line 3554: IF FND_API.To_Boolean(p_init_msg_list) THEN

3550: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
3551: END IF;
3552:
3553: -- Initialize message list if p_init_msg_list is set to TRUE
3554: IF FND_API.To_Boolean(p_init_msg_list) THEN
3555: FND_MSG_PUB.initialize;
3556: END IF;
3557:
3558: -- Initialize API return status to success

Line 3559: l_return_status := FND_API.G_RET_STS_SUCCESS;

3555: FND_MSG_PUB.initialize;
3556: END IF;
3557:
3558: -- Initialize API return status to success
3559: l_return_status := FND_API.G_RET_STS_SUCCESS;
3560:
3561: -- START OF BODY OF API
3562:
3563: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Input:');

Line 3575: RAISE FND_API.G_EXC_ERROR;

3571: FND_MESSAGE.SET_NAME('LNS', 'LNS_INVALID_VALUE');
3572: FND_MESSAGE.SET_TOKEN('PARAMETER', 'LOAN_ID');
3573: FND_MESSAGE.SET_TOKEN('VALUE', P_LOAN_ID);
3574: FND_MSG_PUB.ADD;
3575: RAISE FND_API.G_EXC_ERROR;
3576: end if;
3577:
3578: if P_BASED_ON_TERMS is null then
3579: FND_MESSAGE.SET_NAME('LNS', 'LNS_INVALID_VALUE');

Line 3583: RAISE FND_API.G_EXC_ERROR;

3579: FND_MESSAGE.SET_NAME('LNS', 'LNS_INVALID_VALUE');
3580: FND_MESSAGE.SET_TOKEN('PARAMETER', 'BASED_ON_TERMS');
3581: FND_MESSAGE.SET_TOKEN('VALUE', P_BASED_ON_TERMS);
3582: FND_MSG_PUB.ADD;
3583: RAISE FND_API.G_EXC_ERROR;
3584: end if;
3585:
3586: if P_USE_RETAINED_DATA is not null and P_USE_RETAINED_DATA = 'Y' then
3587: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'G_AMORT_METHOD: ' || G_AMORT_METHOD);

Line 3598: RAISE FND_API.G_EXC_ERROR;

3594: FND_MESSAGE.SET_NAME('LNS', 'LNS_INVALID_VALUE');
3595: FND_MESSAGE.SET_TOKEN('PARAMETER', 'AMORT_METHOD');
3596: FND_MESSAGE.SET_TOKEN('VALUE', P_CUSTOM_SET_REC.AMORT_METHOD);
3597: FND_MSG_PUB.ADD;
3598: RAISE FND_API.G_EXC_ERROR;
3599: end if;
3600:
3601: l_CUSTOM_TBL := P_CUSTOM_TBL;
3602: l_CUSTOM_SET_REC := P_CUSTOM_SET_REC;

Line 3607: P_INIT_MSG_LIST => FND_API.G_TRUE,

3603: end if;
3604:
3605: LNS_CUSTOM_PUB.recalcCustomSchedule(
3606: P_API_VERSION => 1.0,
3607: P_INIT_MSG_LIST => FND_API.G_TRUE,
3608: P_COMMIT => FND_API.G_FALSE,
3609: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,
3610: P_LOAN_ID => P_LOAN_ID,
3611: P_BASED_ON_TERMS => P_BASED_ON_TERMS,

Line 3608: P_COMMIT => FND_API.G_FALSE,

3604:
3605: LNS_CUSTOM_PUB.recalcCustomSchedule(
3606: P_API_VERSION => 1.0,
3607: P_INIT_MSG_LIST => FND_API.G_TRUE,
3608: P_COMMIT => FND_API.G_FALSE,
3609: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,
3610: P_LOAN_ID => P_LOAN_ID,
3611: P_BASED_ON_TERMS => P_BASED_ON_TERMS,
3612: P_USE_RETAINED_DATA => P_USE_RETAINED_DATA,

Line 3609: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,

3605: LNS_CUSTOM_PUB.recalcCustomSchedule(
3606: P_API_VERSION => 1.0,
3607: P_INIT_MSG_LIST => FND_API.G_TRUE,
3608: P_COMMIT => FND_API.G_FALSE,
3609: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,
3610: P_LOAN_ID => P_LOAN_ID,
3611: P_BASED_ON_TERMS => P_BASED_ON_TERMS,
3612: P_USE_RETAINED_DATA => P_USE_RETAINED_DATA,
3613: P_CUSTOM_SET_REC => l_CUSTOM_SET_REC,

Line 3620: RAISE FND_API.G_EXC_ERROR;

3616: x_msg_count => l_msg_count,
3617: x_msg_data => l_msg_data);
3618:
3619: IF l_return_status <> 'S' THEN
3620: RAISE FND_API.G_EXC_ERROR;
3621: END IF;
3622:
3623: l_loan_details := getLoanDetails(p_loan_Id => p_loan_id
3624: ,p_based_on_terms => P_BASED_ON_TERMS);

Line 3660: RAISE FND_API.G_EXC_ERROR;

3656: ,x_msg_count => l_msg_Count
3657: ,x_msg_data => l_msg_Data);
3658:
3659: IF l_return_status <> 'S' THEN
3660: RAISE FND_API.G_EXC_ERROR;
3661: END IF;
3662:
3663: elsif l_custom_tbl(i).ACTION is null or l_custom_tbl(i).ACTION = 'I' then
3664:

Line 3673: RAISE FND_API.G_EXC_ERROR;

3669: ,x_msg_count => l_msg_Count
3670: ,x_msg_data => l_msg_Data);
3671:
3672: IF l_return_status <> 'S' THEN
3673: RAISE FND_API.G_EXC_ERROR;
3674: END IF;
3675:
3676: l_custom_tbl(i).CUSTOM_SCHEDULE_ID := l_custom_sched_id;
3677:

Line 3700: l_loan_header_rec.BILLED_FLAG := FND_API.G_MISS_CHAR;

3696: l_term_rec.NEXT_PAYMENT_DUE_DATE := l_last_billed_due_date;
3697: l_loan_header_rec.BILLED_FLAG := 'Y';
3698: else
3699: l_term_rec.NEXT_PAYMENT_DUE_DATE := l_first_payment_date;
3700: l_loan_header_rec.BILLED_FLAG := FND_API.G_MISS_CHAR;
3701: end if;
3702:
3703: end if;
3704:

Line 3729: lns_loan_header_pub.update_loan(p_init_msg_list => FND_API.G_TRUE

3725:
3726: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'CUSTOM_PAYMENTS_FLAG = ' || l_loan_header_rec.CUSTOM_PAYMENTS_FLAG);
3727: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'BILLED_FLAG = ' || l_loan_header_rec.BILLED_FLAG);
3728:
3729: lns_loan_header_pub.update_loan(p_init_msg_list => FND_API.G_TRUE
3730: ,p_loan_header_rec => l_loan_header_rec
3731: ,P_OBJECT_VERSION_NUMBER => l_object_version
3732: ,X_RETURN_STATUS => l_return_status
3733: ,X_MSG_COUNT => l_msg_count

Line 3744: RAISE FND_API.G_EXC_ERROR;

3740: ELSE
3741: FND_MESSAGE.SET_NAME('LNS', 'LNS_UPD_LOAN_FAIL');
3742: FND_MSG_PUB.Add;
3743: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
3744: RAISE FND_API.G_EXC_ERROR;
3745: end if;
3746: end if;
3747:
3748: -- getting terms version for future update

Line 3765: l_term_rec.ORIG_PAY_CALC_METHOD := FND_API.G_MISS_CHAR;

3761:
3762: if l_loan_details.loan_status <> 'INCOMPLETE' and l_loan_details.CUSTOM_SCHEDULE = 'N' then
3763: l_term_rec.ORIG_PAY_CALC_METHOD := l_loan_details.PAYMENT_CALC_METHOD;
3764: elsif l_loan_details.loan_status = 'INCOMPLETE' then
3765: l_term_rec.ORIG_PAY_CALC_METHOD := FND_API.G_MISS_CHAR;
3766: end if;
3767:
3768: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'PAYMENT_CALC_METHOD = ' || l_term_rec.PAYMENT_CALC_METHOD);
3769: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'CUSTOM_CALC_METHOD = ' || l_term_rec.CUSTOM_CALC_METHOD);

Line 3775: p_init_msg_list => FND_API.G_FALSE,

3771: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'NEXT_PAYMENT_DUE_DATE = ' || l_term_rec.NEXT_PAYMENT_DUE_DATE);
3772: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'CUSTOM_SCHED_DESC = ' || l_term_rec.CUSTOM_SCHED_DESC);
3773:
3774: LNS_TERMS_PUB.update_term(P_OBJECT_VERSION_NUMBER => l_object_version,
3775: p_init_msg_list => FND_API.G_FALSE,
3776: p_loan_term_rec => l_term_rec,
3777: X_RETURN_STATUS => l_return_status,
3778: X_MSG_COUNT => l_msg_count,
3779: X_MSG_DATA => l_msg_data);

Line 3790: RAISE FND_API.G_EXC_ERROR;

3786: -- LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'ERROR: LNS_TERMS_PUB.update_term returned error: ' || substr(l_msg_data,1,225));
3787: FND_MESSAGE.SET_NAME('LNS', 'LNS_UPD_TERM_FAIL');
3788: FND_MSG_PUB.Add;
3789: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
3790: RAISE FND_API.G_EXC_ERROR;
3791: END IF;
3792:
3793: -- getting number of installments and synching rate schedule
3794: if l_custom_tbl.count > 0 then

Line 3817: if P_COMMIT = FND_API.G_TRUE then

3813:
3814: LNS_REP_UTILS.STORE_LOAN_AGREEMENT_CP(p_loan_id, l_agreement_reason);
3815: end if;
3816:
3817: if P_COMMIT = FND_API.G_TRUE then
3818: COMMIT WORK;
3819: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Commited');
3820: end if;
3821:

Line 3823: x_return_status := FND_API.G_RET_STS_SUCCESS;

3819: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Commited');
3820: end if;
3821:
3822: -- END OF BODY OF API
3823: x_return_status := FND_API.G_RET_STS_SUCCESS;
3824:
3825: -- Standard call to get message count and if count is 1, get message info
3826: FND_MSG_PUB.Count_And_Get(
3827: p_encoded => FND_API.G_FALSE,

Line 3827: p_encoded => FND_API.G_FALSE,

3823: x_return_status := FND_API.G_RET_STS_SUCCESS;
3824:
3825: -- Standard call to get message count and if count is 1, get message info
3826: FND_MSG_PUB.Count_And_Get(
3827: p_encoded => FND_API.G_FALSE,
3828: p_count => x_msg_count,
3829: p_data => x_msg_data);
3830:
3831: LogMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, G_PKG_NAME || '.' || l_api_name || ' -');

Line 3834: WHEN FND_API.G_EXC_ERROR THEN

3830:
3831: LogMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, G_PKG_NAME || '.' || l_api_name || ' -');
3832:
3833: EXCEPTION
3834: WHEN FND_API.G_EXC_ERROR THEN
3835: ROLLBACK TO saveCustomSchedule;
3836: x_return_status := FND_API.G_RET_STS_ERROR;
3837: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
3838: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');

Line 3836: x_return_status := FND_API.G_RET_STS_ERROR;

3832:
3833: EXCEPTION
3834: WHEN FND_API.G_EXC_ERROR THEN
3835: ROLLBACK TO saveCustomSchedule;
3836: x_return_status := FND_API.G_RET_STS_ERROR;
3837: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
3838: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');
3839: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
3840: ROLLBACK TO saveCustomSchedule;

Line 3839: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN

3835: ROLLBACK TO saveCustomSchedule;
3836: x_return_status := FND_API.G_RET_STS_ERROR;
3837: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
3838: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');
3839: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
3840: ROLLBACK TO saveCustomSchedule;
3841: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
3842: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
3843: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');

Line 3841: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;

3837: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
3838: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');
3839: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
3840: ROLLBACK TO saveCustomSchedule;
3841: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
3842: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
3843: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');
3844: WHEN OTHERS THEN
3845: ROLLBACK TO saveCustomSchedule;

Line 3846: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;

3842: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
3843: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');
3844: WHEN OTHERS THEN
3845: ROLLBACK TO saveCustomSchedule;
3846: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
3847: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
3848: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');
3849: END;
3850:

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

3895: SAVEPOINT uncustomizeSchedule;
3896: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Savepoint is established');
3897:
3898: -- Standard call to check for call compatibility
3899: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version, l_api_name, G_PKG_NAME) THEN
3900: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
3901: END IF;
3902:
3903: -- Initialize message list if p_init_msg_list is set to TRUE

Line 3900: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;

3896: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Savepoint is established');
3897:
3898: -- Standard call to check for call compatibility
3899: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version, l_api_name, G_PKG_NAME) THEN
3900: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
3901: END IF;
3902:
3903: -- Initialize message list if p_init_msg_list is set to TRUE
3904: IF FND_API.To_Boolean(p_init_msg_list) THEN

Line 3904: IF FND_API.To_Boolean(p_init_msg_list) THEN

3900: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
3901: END IF;
3902:
3903: -- Initialize message list if p_init_msg_list is set to TRUE
3904: IF FND_API.To_Boolean(p_init_msg_list) THEN
3905: FND_MSG_PUB.initialize;
3906: END IF;
3907:
3908: -- Initialize API return status to success

Line 3909: l_return_status := FND_API.G_RET_STS_SUCCESS;

3905: FND_MSG_PUB.initialize;
3906: END IF;
3907:
3908: -- Initialize API return status to success
3909: l_return_status := FND_API.G_RET_STS_SUCCESS;
3910:
3911: -- START OF BODY OF API
3912:
3913: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Input:');

Line 3922: RAISE FND_API.G_EXC_ERROR;

3918: FND_MESSAGE.SET_NAME('LNS', 'LNS_INVALID_VALUE');
3919: FND_MESSAGE.SET_TOKEN('PARAMETER', 'LOAN_ID');
3920: FND_MESSAGE.SET_TOKEN('VALUE', P_LOAN_ID);
3921: FND_MSG_PUB.ADD;
3922: RAISE FND_API.G_EXC_ERROR;
3923: end if;
3924:
3925: l_BASED_ON_TERMS := 'ORIGINATION';
3926: l_loan_details := getLoanDetails(p_loan_Id => p_loan_id

Line 3947: lns_loan_header_pub.update_loan(p_init_msg_list => FND_API.G_TRUE

3943: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Updating lns_loan_headers_all set custom = N');
3944: l_loan_header_rec.loan_id := P_LOAN_ID;
3945: l_loan_header_rec.CUSTOM_PAYMENTS_FLAG := 'N';
3946:
3947: lns_loan_header_pub.update_loan(p_init_msg_list => FND_API.G_TRUE
3948: ,p_loan_header_rec => l_loan_header_rec
3949: ,P_OBJECT_VERSION_NUMBER => l_object_version
3950: ,X_RETURN_STATUS => l_return_status
3951: ,X_MSG_COUNT => l_msg_count

Line 3962: RAISE FND_API.G_EXC_ERROR;

3958: ELSE
3959: FND_MESSAGE.SET_NAME('LNS', 'LNS_UPD_LOAN_FAIL');
3960: FND_MSG_PUB.Add;
3961: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
3962: RAISE FND_API.G_EXC_ERROR;
3963: end if;
3964:
3965: -- getting terms version for future update
3966: select term_id, object_version_number into l_term_id, l_object_version

Line 3976: l_term_rec.CUSTOM_CALC_METHOD := FND_API.G_MISS_CHAR;

3972:
3973: l_term_rec.TERM_ID := l_term_id;
3974: l_term_rec.LOAN_ID := p_loan_id;
3975: l_term_rec.PAYMENT_CALC_METHOD := P_ST_AMORT_METHOD;
3976: l_term_rec.CUSTOM_CALC_METHOD := FND_API.G_MISS_CHAR;
3977: l_term_rec.ORIG_PAY_CALC_METHOD := FND_API.G_MISS_CHAR;
3978:
3979: LNS_TERMS_PUB.update_term(P_OBJECT_VERSION_NUMBER => l_object_version,
3980: p_init_msg_list => FND_API.G_FALSE,

Line 3977: l_term_rec.ORIG_PAY_CALC_METHOD := FND_API.G_MISS_CHAR;

3973: l_term_rec.TERM_ID := l_term_id;
3974: l_term_rec.LOAN_ID := p_loan_id;
3975: l_term_rec.PAYMENT_CALC_METHOD := P_ST_AMORT_METHOD;
3976: l_term_rec.CUSTOM_CALC_METHOD := FND_API.G_MISS_CHAR;
3977: l_term_rec.ORIG_PAY_CALC_METHOD := FND_API.G_MISS_CHAR;
3978:
3979: LNS_TERMS_PUB.update_term(P_OBJECT_VERSION_NUMBER => l_object_version,
3980: p_init_msg_list => FND_API.G_FALSE,
3981: p_loan_term_rec => l_term_rec,

Line 3980: p_init_msg_list => FND_API.G_FALSE,

3976: l_term_rec.CUSTOM_CALC_METHOD := FND_API.G_MISS_CHAR;
3977: l_term_rec.ORIG_PAY_CALC_METHOD := FND_API.G_MISS_CHAR;
3978:
3979: LNS_TERMS_PUB.update_term(P_OBJECT_VERSION_NUMBER => l_object_version,
3980: p_init_msg_list => FND_API.G_FALSE,
3981: p_loan_term_rec => l_term_rec,
3982: X_RETURN_STATUS => l_return_status,
3983: X_MSG_COUNT => l_msg_count,
3984: X_MSG_DATA => l_msg_data);

Line 3995: RAISE FND_API.G_EXC_ERROR;

3991: -- LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'ERROR: LNS_TERMS_PUB.update_term returned error: ' || substr(l_msg_data,1,225));
3992: FND_MESSAGE.SET_NAME('LNS', 'LNS_UPD_TERM_FAIL');
3993: FND_MSG_PUB.Add;
3994: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
3995: RAISE FND_API.G_EXC_ERROR;
3996: END IF;
3997:
3998: -- synching rate schedule
3999: l_num_installments := LNS_FIN_UTILS.getNumberInstallments(p_loan_id);

Line 4006: if P_COMMIT = FND_API.G_TRUE then

4002: else
4003: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Nothing to update');
4004: end if;
4005:
4006: if P_COMMIT = FND_API.G_TRUE then
4007: COMMIT WORK;
4008: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Commited');
4009: end if;
4010:

Line 4012: x_return_status := FND_API.G_RET_STS_SUCCESS;

4008: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Commited');
4009: end if;
4010:
4011: -- END OF BODY OF API
4012: x_return_status := FND_API.G_RET_STS_SUCCESS;
4013:
4014: -- Standard call to get message count and if count is 1, get message info
4015: FND_MSG_PUB.Count_And_Get(
4016: p_encoded => FND_API.G_FALSE,

Line 4016: p_encoded => FND_API.G_FALSE,

4012: x_return_status := FND_API.G_RET_STS_SUCCESS;
4013:
4014: -- Standard call to get message count and if count is 1, get message info
4015: FND_MSG_PUB.Count_And_Get(
4016: p_encoded => FND_API.G_FALSE,
4017: p_count => x_msg_count,
4018: p_data => x_msg_data);
4019:
4020: LogMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, G_PKG_NAME || '.' || l_api_name || ' -');

Line 4023: WHEN FND_API.G_EXC_ERROR THEN

4019:
4020: LogMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, G_PKG_NAME || '.' || l_api_name || ' -');
4021:
4022: EXCEPTION
4023: WHEN FND_API.G_EXC_ERROR THEN
4024: ROLLBACK TO uncustomizeSchedule;
4025: x_return_status := FND_API.G_RET_STS_ERROR;
4026: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
4027: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');

Line 4025: x_return_status := FND_API.G_RET_STS_ERROR;

4021:
4022: EXCEPTION
4023: WHEN FND_API.G_EXC_ERROR THEN
4024: ROLLBACK TO uncustomizeSchedule;
4025: x_return_status := FND_API.G_RET_STS_ERROR;
4026: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
4027: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');
4028: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
4029: ROLLBACK TO uncustomizeSchedule;

Line 4028: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN

4024: ROLLBACK TO uncustomizeSchedule;
4025: x_return_status := FND_API.G_RET_STS_ERROR;
4026: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
4027: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');
4028: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
4029: ROLLBACK TO uncustomizeSchedule;
4030: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
4031: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
4032: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');

Line 4030: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;

4026: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
4027: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');
4028: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
4029: ROLLBACK TO uncustomizeSchedule;
4030: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
4031: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
4032: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');
4033: WHEN OTHERS THEN
4034: ROLLBACK TO uncustomizeSchedule;

Line 4035: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;

4031: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
4032: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');
4033: WHEN OTHERS THEN
4034: ROLLBACK TO uncustomizeSchedule;
4035: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
4036: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
4037: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');
4038: END;
4039:

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

4125: SAVEPOINT customizeSchedule;
4126: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Savepoint is established');
4127:
4128: -- Standard call to check for call compatibility
4129: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version, l_api_name, G_PKG_NAME) THEN
4130: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
4131: END IF;
4132:
4133: -- Initialize message list if p_init_msg_list is set to TRUE

Line 4130: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;

4126: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Savepoint is established');
4127:
4128: -- Standard call to check for call compatibility
4129: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version, l_api_name, G_PKG_NAME) THEN
4130: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
4131: END IF;
4132:
4133: -- Initialize message list if p_init_msg_list is set to TRUE
4134: IF FND_API.To_Boolean(p_init_msg_list) THEN

Line 4134: IF FND_API.To_Boolean(p_init_msg_list) THEN

4130: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
4131: END IF;
4132:
4133: -- Initialize message list if p_init_msg_list is set to TRUE
4134: IF FND_API.To_Boolean(p_init_msg_list) THEN
4135: FND_MSG_PUB.initialize;
4136: END IF;
4137:
4138: -- Initialize API return status to success

Line 4139: l_return_status := FND_API.G_RET_STS_SUCCESS;

4135: FND_MSG_PUB.initialize;
4136: END IF;
4137:
4138: -- Initialize API return status to success
4139: l_return_status := FND_API.G_RET_STS_SUCCESS;
4140:
4141: -- START OF BODY OF API
4142:
4143: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Input:');

Line 4151: RAISE FND_API.G_EXC_ERROR;

4147: FND_MESSAGE.SET_NAME('LNS', 'LNS_INVALID_VALUE');
4148: FND_MESSAGE.SET_TOKEN('PARAMETER', 'LOAN_ID');
4149: FND_MESSAGE.SET_TOKEN('VALUE', P_LOAN_ID);
4150: FND_MSG_PUB.ADD;
4151: RAISE FND_API.G_EXC_ERROR;
4152: end if;
4153:
4154: parseClob(
4155: P_API_VERSION => 1.0,

Line 4156: P_INIT_MSG_LIST => FND_API.G_TRUE,

4152: end if;
4153:
4154: parseClob(
4155: P_API_VERSION => 1.0,
4156: P_INIT_MSG_LIST => FND_API.G_TRUE,
4157: P_COMMIT => FND_API.G_FALSE,
4158: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,
4159: P_CLOB => P_CLOB,
4160: P_RETAIN_DATA => 'Y',

Line 4157: P_COMMIT => FND_API.G_FALSE,

4153:
4154: parseClob(
4155: P_API_VERSION => 1.0,
4156: P_INIT_MSG_LIST => FND_API.G_TRUE,
4157: P_COMMIT => FND_API.G_FALSE,
4158: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,
4159: P_CLOB => P_CLOB,
4160: P_RETAIN_DATA => 'Y',
4161: X_CUSTOM_SET_REC => l_CUSTOM_SET_REC,

Line 4158: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,

4154: parseClob(
4155: P_API_VERSION => 1.0,
4156: P_INIT_MSG_LIST => FND_API.G_TRUE,
4157: P_COMMIT => FND_API.G_FALSE,
4158: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,
4159: P_CLOB => P_CLOB,
4160: P_RETAIN_DATA => 'Y',
4161: X_CUSTOM_SET_REC => l_CUSTOM_SET_REC,
4162: X_CUSTOM_TBL => l_CUSTOM_TBL,

Line 4168: RAISE FND_API.G_EXC_ERROR;

4164: x_msg_count => l_msg_count,
4165: x_msg_data => l_msg_data);
4166:
4167: IF l_return_status <> 'S' THEN
4168: RAISE FND_API.G_EXC_ERROR;
4169: END IF;
4170: /*
4171: -- getting CUSTOM_CALC_METHOD from lns_terms
4172: select CUSTOM_CALC_METHOD into l_AMORT_METHOD

Line 4189: P_INIT_MSG_LIST => FND_API.G_TRUE,

4185:
4186: -- immediatly save it
4187: LNS_CUSTOM_PUB.saveCustomSchedule(
4188: P_API_VERSION => 1.0,
4189: P_INIT_MSG_LIST => FND_API.G_TRUE,
4190: P_COMMIT => FND_API.G_FALSE,
4191: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,
4192: P_LOAN_ID => P_LOAN_ID,
4193: P_BASED_ON_TERMS => l_BASED_ON_TERMS,

Line 4190: P_COMMIT => FND_API.G_FALSE,

4186: -- immediatly save it
4187: LNS_CUSTOM_PUB.saveCustomSchedule(
4188: P_API_VERSION => 1.0,
4189: P_INIT_MSG_LIST => FND_API.G_TRUE,
4190: P_COMMIT => FND_API.G_FALSE,
4191: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,
4192: P_LOAN_ID => P_LOAN_ID,
4193: P_BASED_ON_TERMS => l_BASED_ON_TERMS,
4194: P_USE_RETAINED_DATA => 'Y',

Line 4191: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,

4187: LNS_CUSTOM_PUB.saveCustomSchedule(
4188: P_API_VERSION => 1.0,
4189: P_INIT_MSG_LIST => FND_API.G_TRUE,
4190: P_COMMIT => FND_API.G_FALSE,
4191: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,
4192: P_LOAN_ID => P_LOAN_ID,
4193: P_BASED_ON_TERMS => l_BASED_ON_TERMS,
4194: P_USE_RETAINED_DATA => 'Y',
4195: P_CUSTOM_SET_REC => l_CUSTOM_SET_REC,

Line 4202: RAISE FND_API.G_EXC_ERROR;

4198: x_msg_count => l_msg_count,
4199: x_msg_data => l_msg_data);
4200:
4201: IF l_return_status <> 'S' THEN
4202: RAISE FND_API.G_EXC_ERROR;
4203: END IF;
4204:
4205: -- clear retained date
4206: LNS_CUSTOM_PUB.clearRetainedSchedule(

Line 4208: P_INIT_MSG_LIST => FND_API.G_TRUE,

4204:
4205: -- clear retained date
4206: LNS_CUSTOM_PUB.clearRetainedSchedule(
4207: P_API_VERSION => 1.0,
4208: P_INIT_MSG_LIST => FND_API.G_TRUE,
4209: P_COMMIT => FND_API.G_FALSE,
4210: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,
4211: x_return_status => l_return_status,
4212: x_msg_count => l_msg_count,

Line 4209: P_COMMIT => FND_API.G_FALSE,

4205: -- clear retained date
4206: LNS_CUSTOM_PUB.clearRetainedSchedule(
4207: P_API_VERSION => 1.0,
4208: P_INIT_MSG_LIST => FND_API.G_TRUE,
4209: P_COMMIT => FND_API.G_FALSE,
4210: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,
4211: x_return_status => l_return_status,
4212: x_msg_count => l_msg_count,
4213: x_msg_data => l_msg_data);

Line 4210: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,

4206: LNS_CUSTOM_PUB.clearRetainedSchedule(
4207: P_API_VERSION => 1.0,
4208: P_INIT_MSG_LIST => FND_API.G_TRUE,
4209: P_COMMIT => FND_API.G_FALSE,
4210: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,
4211: x_return_status => l_return_status,
4212: x_msg_count => l_msg_count,
4213: x_msg_data => l_msg_data);
4214:

Line 4216: RAISE FND_API.G_EXC_ERROR;

4212: x_msg_count => l_msg_count,
4213: x_msg_data => l_msg_data);
4214:
4215: IF l_return_status <> 'S' THEN
4216: RAISE FND_API.G_EXC_ERROR;
4217: END IF;
4218:
4219: X_CUSTOM_TBL := l_CUSTOM_TBL;
4220: if P_COMMIT = FND_API.G_TRUE then

Line 4220: if P_COMMIT = FND_API.G_TRUE then

4216: RAISE FND_API.G_EXC_ERROR;
4217: END IF;
4218:
4219: X_CUSTOM_TBL := l_CUSTOM_TBL;
4220: if P_COMMIT = FND_API.G_TRUE then
4221: COMMIT WORK;
4222: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Commited');
4223: end if;
4224:

Line 4226: x_return_status := FND_API.G_RET_STS_SUCCESS;

4222: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Commited');
4223: end if;
4224:
4225: -- END OF BODY OF API
4226: x_return_status := FND_API.G_RET_STS_SUCCESS;
4227:
4228: -- Standard call to get message count and if count is 1, get message info
4229: FND_MSG_PUB.Count_And_Get(
4230: p_encoded => FND_API.G_FALSE,

Line 4230: p_encoded => FND_API.G_FALSE,

4226: x_return_status := FND_API.G_RET_STS_SUCCESS;
4227:
4228: -- Standard call to get message count and if count is 1, get message info
4229: FND_MSG_PUB.Count_And_Get(
4230: p_encoded => FND_API.G_FALSE,
4231: p_count => x_msg_count,
4232: p_data => x_msg_data);
4233:
4234: LogMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, G_PKG_NAME || '.' || l_api_name || ' -');

Line 4237: WHEN FND_API.G_EXC_ERROR THEN

4233:
4234: LogMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, G_PKG_NAME || '.' || l_api_name || ' -');
4235:
4236: EXCEPTION
4237: WHEN FND_API.G_EXC_ERROR THEN
4238: ROLLBACK TO customizeSchedule;
4239: x_return_status := FND_API.G_RET_STS_ERROR;
4240: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
4241: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');

Line 4239: x_return_status := FND_API.G_RET_STS_ERROR;

4235:
4236: EXCEPTION
4237: WHEN FND_API.G_EXC_ERROR THEN
4238: ROLLBACK TO customizeSchedule;
4239: x_return_status := FND_API.G_RET_STS_ERROR;
4240: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
4241: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');
4242: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
4243: ROLLBACK TO customizeSchedule;

Line 4242: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN

4238: ROLLBACK TO customizeSchedule;
4239: x_return_status := FND_API.G_RET_STS_ERROR;
4240: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
4241: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');
4242: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
4243: ROLLBACK TO customizeSchedule;
4244: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
4245: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
4246: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');

Line 4244: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;

4240: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
4241: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');
4242: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
4243: ROLLBACK TO customizeSchedule;
4244: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
4245: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
4246: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');
4247: WHEN OTHERS THEN
4248: ROLLBACK TO customizeSchedule;

Line 4249: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;

4245: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
4246: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');
4247: WHEN OTHERS THEN
4248: ROLLBACK TO customizeSchedule;
4249: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
4250: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
4251: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');
4252: END;
4253:

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

4379: SAVEPOINT shiftCustomSchedule;
4380: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Savepoint is established');
4381:
4382: -- Standard call to check for call compatibility
4383: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version, l_api_name, G_PKG_NAME) THEN
4384: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
4385: END IF;
4386:
4387: -- Initialize message list if p_init_msg_list is set to TRUE

Line 4384: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;

4380: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Savepoint is established');
4381:
4382: -- Standard call to check for call compatibility
4383: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version, l_api_name, G_PKG_NAME) THEN
4384: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
4385: END IF;
4386:
4387: -- Initialize message list if p_init_msg_list is set to TRUE
4388: IF FND_API.To_Boolean(p_init_msg_list) THEN

Line 4388: IF FND_API.To_Boolean(p_init_msg_list) THEN

4384: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
4385: END IF;
4386:
4387: -- Initialize message list if p_init_msg_list is set to TRUE
4388: IF FND_API.To_Boolean(p_init_msg_list) THEN
4389: FND_MSG_PUB.initialize;
4390: END IF;
4391:
4392: -- Initialize API return status to success

Line 4393: l_return_status := FND_API.G_RET_STS_SUCCESS;

4389: FND_MSG_PUB.initialize;
4390: END IF;
4391:
4392: -- Initialize API return status to success
4393: l_return_status := FND_API.G_RET_STS_SUCCESS;
4394:
4395: -- START OF BODY OF API
4396:
4397: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Input:');

Line 4410: RAISE FND_API.G_EXC_ERROR;

4406: FND_MESSAGE.SET_NAME('LNS', 'LNS_INVALID_VALUE');
4407: FND_MESSAGE.SET_TOKEN('PARAMETER', 'LOAN_ID');
4408: FND_MESSAGE.SET_TOKEN('VALUE', P_LOAN_ID);
4409: FND_MSG_PUB.ADD;
4410: RAISE FND_API.G_EXC_ERROR;
4411: end if;
4412:
4413: if P_BASED_ON_TERMS is null then
4414: FND_MESSAGE.SET_NAME('LNS', 'LNS_INVALID_VALUE');

Line 4418: RAISE FND_API.G_EXC_ERROR;

4414: FND_MESSAGE.SET_NAME('LNS', 'LNS_INVALID_VALUE');
4415: FND_MESSAGE.SET_TOKEN('PARAMETER', 'BASED_ON_TERMS');
4416: FND_MESSAGE.SET_TOKEN('VALUE', P_BASED_ON_TERMS);
4417: FND_MSG_PUB.ADD;
4418: RAISE FND_API.G_EXC_ERROR;
4419: end if;
4420:
4421: if P_CUSTOM_SET_REC.AMORT_METHOD is null then
4422: FND_MESSAGE.SET_NAME('LNS', 'LNS_INVALID_VALUE');

Line 4426: RAISE FND_API.G_EXC_ERROR;

4422: FND_MESSAGE.SET_NAME('LNS', 'LNS_INVALID_VALUE');
4423: FND_MESSAGE.SET_TOKEN('PARAMETER', 'AMORT_METHOD');
4424: FND_MESSAGE.SET_TOKEN('VALUE', P_CUSTOM_SET_REC.AMORT_METHOD);
4425: FND_MSG_PUB.ADD;
4426: RAISE FND_API.G_EXC_ERROR;
4427: end if;
4428:
4429: if P_NEW_DUE_DATE is null then
4430: FND_MESSAGE.SET_NAME('LNS', 'LNS_INVALID_VALUE');

Line 4434: RAISE FND_API.G_EXC_ERROR;

4430: FND_MESSAGE.SET_NAME('LNS', 'LNS_INVALID_VALUE');
4431: FND_MESSAGE.SET_TOKEN('PARAMETER', 'NEW_DUE_DATE');
4432: FND_MESSAGE.SET_TOKEN('VALUE', P_NEW_DUE_DATE);
4433: FND_MSG_PUB.ADD;
4434: RAISE FND_API.G_EXC_ERROR;
4435: end if;
4436:
4437: l_CUSTOM_TBL := P_CUSTOM_TBL;
4438: l_CUSTOM_SET_REC := P_CUSTOM_SET_REC;

Line 4446: RAISE FND_API.G_EXC_ERROR;

4442: -- LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'ERROR: Custom amortization is empty.');
4443: FND_MESSAGE.SET_NAME('LNS', 'LNS_CUST_AMORT_EMPTY');
4444: FND_MSG_PUB.Add;
4445: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
4446: RAISE FND_API.G_EXC_ERROR;
4447: end if;
4448:
4449: l_return := shiftRowsByDate(P_OLD_DUE_DATE => P_OLD_DUE_DATE,
4450: P_NEW_DUE_DATE => P_NEW_DUE_DATE,

Line 4459: P_INIT_MSG_LIST => FND_API.G_TRUE,

4455: end if;
4456:
4457: LNS_CUSTOM_PUB.recalcCustomSchedule(
4458: P_API_VERSION => 1.0,
4459: P_INIT_MSG_LIST => FND_API.G_TRUE,
4460: P_COMMIT => FND_API.G_FALSE,
4461: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,
4462: P_LOAN_ID => P_LOAN_ID,
4463: P_BASED_ON_TERMS => P_BASED_ON_TERMS,

Line 4460: P_COMMIT => FND_API.G_FALSE,

4456:
4457: LNS_CUSTOM_PUB.recalcCustomSchedule(
4458: P_API_VERSION => 1.0,
4459: P_INIT_MSG_LIST => FND_API.G_TRUE,
4460: P_COMMIT => FND_API.G_FALSE,
4461: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,
4462: P_LOAN_ID => P_LOAN_ID,
4463: P_BASED_ON_TERMS => P_BASED_ON_TERMS,
4464: P_USE_RETAINED_DATA => 'N',

Line 4461: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,

4457: LNS_CUSTOM_PUB.recalcCustomSchedule(
4458: P_API_VERSION => 1.0,
4459: P_INIT_MSG_LIST => FND_API.G_TRUE,
4460: P_COMMIT => FND_API.G_FALSE,
4461: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,
4462: P_LOAN_ID => P_LOAN_ID,
4463: P_BASED_ON_TERMS => P_BASED_ON_TERMS,
4464: P_USE_RETAINED_DATA => 'N',
4465: P_CUSTOM_SET_REC => l_CUSTOM_SET_REC,

Line 4472: RAISE FND_API.G_EXC_ERROR;

4468: x_msg_count => l_msg_count,
4469: x_msg_data => l_msg_data);
4470:
4471: IF l_return_status <> 'S' THEN
4472: RAISE FND_API.G_EXC_ERROR;
4473: END IF;
4474:
4475: P_CUSTOM_TBL := l_CUSTOM_TBL;
4476:

Line 4477: if P_COMMIT = FND_API.G_TRUE then

4473: END IF;
4474:
4475: P_CUSTOM_TBL := l_CUSTOM_TBL;
4476:
4477: if P_COMMIT = FND_API.G_TRUE then
4478: COMMIT WORK;
4479: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Commited');
4480: end if;
4481:

Line 4483: x_return_status := FND_API.G_RET_STS_SUCCESS;

4479: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Commited');
4480: end if;
4481:
4482: -- END OF BODY OF API
4483: x_return_status := FND_API.G_RET_STS_SUCCESS;
4484:
4485: -- Standard call to get message count and if count is 1, get message info
4486: FND_MSG_PUB.Count_And_Get(
4487: p_encoded => FND_API.G_FALSE,

Line 4487: p_encoded => FND_API.G_FALSE,

4483: x_return_status := FND_API.G_RET_STS_SUCCESS;
4484:
4485: -- Standard call to get message count and if count is 1, get message info
4486: FND_MSG_PUB.Count_And_Get(
4487: p_encoded => FND_API.G_FALSE,
4488: p_count => x_msg_count,
4489: p_data => x_msg_data);
4490:
4491: LogMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, G_PKG_NAME || '.' || l_api_name || ' -');

Line 4494: WHEN FND_API.G_EXC_ERROR THEN

4490:
4491: LogMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, G_PKG_NAME || '.' || l_api_name || ' -');
4492:
4493: EXCEPTION
4494: WHEN FND_API.G_EXC_ERROR THEN
4495: ROLLBACK TO shiftCustomSchedule;
4496: x_return_status := FND_API.G_RET_STS_ERROR;
4497: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
4498: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');

Line 4496: x_return_status := FND_API.G_RET_STS_ERROR;

4492:
4493: EXCEPTION
4494: WHEN FND_API.G_EXC_ERROR THEN
4495: ROLLBACK TO shiftCustomSchedule;
4496: x_return_status := FND_API.G_RET_STS_ERROR;
4497: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
4498: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');
4499: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
4500: ROLLBACK TO shiftCustomSchedule;

Line 4499: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN

4495: ROLLBACK TO shiftCustomSchedule;
4496: x_return_status := FND_API.G_RET_STS_ERROR;
4497: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
4498: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');
4499: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
4500: ROLLBACK TO shiftCustomSchedule;
4501: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
4502: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
4503: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');

Line 4501: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;

4497: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
4498: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');
4499: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
4500: ROLLBACK TO shiftCustomSchedule;
4501: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
4502: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
4503: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');
4504: WHEN OTHERS THEN
4505: ROLLBACK TO shiftCustomSchedule;

Line 4506: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;

4502: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
4503: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');
4504: WHEN OTHERS THEN
4505: ROLLBACK TO shiftCustomSchedule;
4506: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
4507: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
4508: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');
4509: END;
4510:

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

4552: SAVEPOINT reBuildCustomdSchedule;
4553: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Savepoint is established');
4554:
4555: -- Standard call to check for call compatibility
4556: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version, l_api_name, G_PKG_NAME) THEN
4557: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
4558: END IF;
4559:
4560: -- Initialize message list if p_init_msg_list is set to TRUE

Line 4557: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;

4553: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Savepoint is established');
4554:
4555: -- Standard call to check for call compatibility
4556: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version, l_api_name, G_PKG_NAME) THEN
4557: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
4558: END IF;
4559:
4560: -- Initialize message list if p_init_msg_list is set to TRUE
4561: IF FND_API.To_Boolean(p_init_msg_list) THEN

Line 4561: IF FND_API.To_Boolean(p_init_msg_list) THEN

4557: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
4558: END IF;
4559:
4560: -- Initialize message list if p_init_msg_list is set to TRUE
4561: IF FND_API.To_Boolean(p_init_msg_list) THEN
4562: FND_MSG_PUB.initialize;
4563: END IF;
4564:
4565: -- Initialize API return status to success

Line 4566: l_return_status := FND_API.G_RET_STS_SUCCESS;

4562: FND_MSG_PUB.initialize;
4563: END IF;
4564:
4565: -- Initialize API return status to success
4566: l_return_status := FND_API.G_RET_STS_SUCCESS;
4567:
4568: -- START OF BODY OF API
4569:
4570: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Input:');

Line 4578: RAISE FND_API.G_EXC_ERROR;

4574: FND_MESSAGE.SET_NAME('LNS', 'LNS_INVALID_VALUE');
4575: FND_MESSAGE.SET_TOKEN('PARAMETER', 'LOAN_ID');
4576: FND_MESSAGE.SET_TOKEN('VALUE', P_LOAN_ID);
4577: FND_MSG_PUB.ADD;
4578: RAISE FND_API.G_EXC_ERROR;
4579: end if;
4580:
4581: l_BASED_ON_TERMS := 'ORIGINATION';
4582: l_loan_details := getLoanDetails(p_loan_Id => p_loan_id

Line 4601: if P_COMMIT = FND_API.G_TRUE then

4597: else
4598: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Nothing to update');
4599: end if;
4600:
4601: if P_COMMIT = FND_API.G_TRUE then
4602: COMMIT WORK;
4603: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Commited');
4604: end if;
4605:

Line 4607: x_return_status := FND_API.G_RET_STS_SUCCESS;

4603: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Commited');
4604: end if;
4605:
4606: -- END OF BODY OF API
4607: x_return_status := FND_API.G_RET_STS_SUCCESS;
4608:
4609: -- Standard call to get message count and if count is 1, get message info
4610: FND_MSG_PUB.Count_And_Get(
4611: p_encoded => FND_API.G_FALSE,

Line 4611: p_encoded => FND_API.G_FALSE,

4607: x_return_status := FND_API.G_RET_STS_SUCCESS;
4608:
4609: -- Standard call to get message count and if count is 1, get message info
4610: FND_MSG_PUB.Count_And_Get(
4611: p_encoded => FND_API.G_FALSE,
4612: p_count => x_msg_count,
4613: p_data => x_msg_data);
4614:
4615: LogMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, G_PKG_NAME || '.' || l_api_name || ' -');

Line 4618: WHEN FND_API.G_EXC_ERROR THEN

4614:
4615: LogMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, G_PKG_NAME || '.' || l_api_name || ' -');
4616:
4617: EXCEPTION
4618: WHEN FND_API.G_EXC_ERROR THEN
4619: ROLLBACK TO reBuildCustomdSchedule;
4620: x_return_status := FND_API.G_RET_STS_ERROR;
4621: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
4622: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');

Line 4620: x_return_status := FND_API.G_RET_STS_ERROR;

4616:
4617: EXCEPTION
4618: WHEN FND_API.G_EXC_ERROR THEN
4619: ROLLBACK TO reBuildCustomdSchedule;
4620: x_return_status := FND_API.G_RET_STS_ERROR;
4621: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
4622: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');
4623: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
4624: ROLLBACK TO reBuildCustomdSchedule;

Line 4623: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN

4619: ROLLBACK TO reBuildCustomdSchedule;
4620: x_return_status := FND_API.G_RET_STS_ERROR;
4621: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
4622: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');
4623: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
4624: ROLLBACK TO reBuildCustomdSchedule;
4625: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
4626: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
4627: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');

Line 4625: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;

4621: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
4622: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');
4623: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
4624: ROLLBACK TO reBuildCustomdSchedule;
4625: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
4626: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
4627: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');
4628: WHEN OTHERS THEN
4629: ROLLBACK TO reBuildCustomdSchedule;

Line 4630: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;

4626: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
4627: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');
4628: WHEN OTHERS THEN
4629: ROLLBACK TO reBuildCustomdSchedule;
4630: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
4631: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
4632: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');
4633: END;
4634:

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

4791: SAVEPOINT addMissingInstallment;
4792: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Savepoint is established');
4793:
4794: -- Standard call to check for call compatibility
4795: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version, l_api_name, G_PKG_NAME) THEN
4796: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
4797: END IF;
4798:
4799: -- Initialize message list if p_init_msg_list is set to TRUE

Line 4796: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;

4792: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Savepoint is established');
4793:
4794: -- Standard call to check for call compatibility
4795: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version, l_api_name, G_PKG_NAME) THEN
4796: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
4797: END IF;
4798:
4799: -- Initialize message list if p_init_msg_list is set to TRUE
4800: IF FND_API.To_Boolean(p_init_msg_list) THEN

Line 4800: IF FND_API.To_Boolean(p_init_msg_list) THEN

4796: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
4797: END IF;
4798:
4799: -- Initialize message list if p_init_msg_list is set to TRUE
4800: IF FND_API.To_Boolean(p_init_msg_list) THEN
4801: FND_MSG_PUB.initialize;
4802: END IF;
4803:
4804: -- Initialize API return status to success

Line 4805: X_RETURN_STATUS := FND_API.G_RET_STS_SUCCESS;

4801: FND_MSG_PUB.initialize;
4802: END IF;
4803:
4804: -- Initialize API return status to success
4805: X_RETURN_STATUS := FND_API.G_RET_STS_SUCCESS;
4806:
4807: -- START OF BODY OF API
4808: l_INSTALLMENT_REC := P_INSTALLMENT_REC;
4809:

Line 4827: RAISE FND_API.G_EXC_ERROR;

4823: FND_MESSAGE.SET_TOKEN('PARAMETER', 'LOAN_ID');
4824: FND_MESSAGE.SET_TOKEN('VALUE', l_INSTALLMENT_REC.LOAN_ID);
4825: FND_MSG_PUB.ADD;
4826: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
4827: RAISE FND_API.G_EXC_ERROR;
4828: end if;
4829:
4830: if l_INSTALLMENT_REC.PAYMENT_NUMBER is null then
4831: FND_MESSAGE.SET_NAME('LNS', 'LNS_INVALID_VALUE');

Line 4836: RAISE FND_API.G_EXC_ERROR;

4832: FND_MESSAGE.SET_TOKEN('PARAMETER', 'PAYMENT_NUMBER');
4833: FND_MESSAGE.SET_TOKEN('VALUE', l_INSTALLMENT_REC.PAYMENT_NUMBER);
4834: FND_MSG_PUB.ADD;
4835: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
4836: RAISE FND_API.G_EXC_ERROR;
4837: end if;
4838:
4839: if l_INSTALLMENT_REC.DUE_DATE is null then
4840: FND_MESSAGE.SET_NAME('LNS', 'LNS_INVALID_VALUE');

Line 4845: RAISE FND_API.G_EXC_ERROR;

4841: FND_MESSAGE.SET_TOKEN('PARAMETER', 'DUE_DATE');
4842: FND_MESSAGE.SET_TOKEN('VALUE', l_INSTALLMENT_REC.DUE_DATE);
4843: FND_MSG_PUB.ADD;
4844: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
4845: RAISE FND_API.G_EXC_ERROR;
4846: end if;
4847:
4848: open c_exist_installment(l_INSTALLMENT_REC.LOAN_ID, l_INSTALLMENT_REC.PAYMENT_NUMBER);
4849: fetch c_exist_installment into l_custom_sched_id;

Line 4898: RAISE FND_API.G_EXC_ERROR;

4894: ,x_msg_data => l_msg_Data);
4895:
4896: IF l_return_status <> 'S' THEN
4897: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Failed to insert custom schedule row');
4898: RAISE FND_API.G_EXC_ERROR;
4899: END IF;
4900:
4901: if P_COMMIT = FND_API.G_TRUE then
4902: COMMIT WORK;

Line 4901: if P_COMMIT = FND_API.G_TRUE then

4897: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Failed to insert custom schedule row');
4898: RAISE FND_API.G_EXC_ERROR;
4899: END IF;
4900:
4901: if P_COMMIT = FND_API.G_TRUE then
4902: COMMIT WORK;
4903: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Commited');
4904: end if;
4905:

Line 4909: x_return_status := FND_API.G_RET_STS_SUCCESS;

4905:
4906: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Successfully added installment ' || l_INSTALLMENT_REC.PAYMENT_NUMBER || ' to custom schedule');
4907:
4908: -- END OF BODY OF API
4909: x_return_status := FND_API.G_RET_STS_SUCCESS;
4910:
4911: -- Standard call to get message count and if count is 1, get message info
4912: FND_MSG_PUB.Count_And_Get(
4913: p_encoded => FND_API.G_FALSE,

Line 4913: p_encoded => FND_API.G_FALSE,

4909: x_return_status := FND_API.G_RET_STS_SUCCESS;
4910:
4911: -- Standard call to get message count and if count is 1, get message info
4912: FND_MSG_PUB.Count_And_Get(
4913: p_encoded => FND_API.G_FALSE,
4914: p_count => x_msg_count,
4915: p_data => x_msg_data);
4916:
4917: LogMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, G_PKG_NAME || '.' || l_api_name || ' -');

Line 4920: WHEN FND_API.G_EXC_ERROR THEN

4916:
4917: LogMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, G_PKG_NAME || '.' || l_api_name || ' -');
4918:
4919: EXCEPTION
4920: WHEN FND_API.G_EXC_ERROR THEN
4921: ROLLBACK TO addMissingInstallment;
4922: x_return_status := FND_API.G_RET_STS_ERROR;
4923: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
4924: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');

Line 4922: x_return_status := FND_API.G_RET_STS_ERROR;

4918:
4919: EXCEPTION
4920: WHEN FND_API.G_EXC_ERROR THEN
4921: ROLLBACK TO addMissingInstallment;
4922: x_return_status := FND_API.G_RET_STS_ERROR;
4923: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
4924: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');
4925: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
4926: ROLLBACK TO addMissingInstallment;

Line 4925: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN

4921: ROLLBACK TO addMissingInstallment;
4922: x_return_status := FND_API.G_RET_STS_ERROR;
4923: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
4924: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');
4925: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
4926: ROLLBACK TO addMissingInstallment;
4927: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
4928: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
4929: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');

Line 4927: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;

4923: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
4924: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');
4925: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
4926: ROLLBACK TO addMissingInstallment;
4927: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
4928: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
4929: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');
4930: WHEN OTHERS THEN
4931: ROLLBACK TO addMissingInstallment;

Line 4932: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;

4928: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
4929: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');
4930: WHEN OTHERS THEN
4931: ROLLBACK TO addMissingInstallment;
4932: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
4933: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
4934: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');
4935: END;
4936:

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

5061: SAVEPOINT parseClob;
5062: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Savepoint is established');
5063:
5064: -- Standard call to check for call compatibility
5065: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version, l_api_name, G_PKG_NAME) THEN
5066: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
5067: END IF;
5068:
5069: -- Initialize message list if p_init_msg_list is set to TRUE

Line 5066: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;

5062: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Savepoint is established');
5063:
5064: -- Standard call to check for call compatibility
5065: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version, l_api_name, G_PKG_NAME) THEN
5066: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
5067: END IF;
5068:
5069: -- Initialize message list if p_init_msg_list is set to TRUE
5070: IF FND_API.To_Boolean(p_init_msg_list) THEN

Line 5070: IF FND_API.To_Boolean(p_init_msg_list) THEN

5066: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
5067: END IF;
5068:
5069: -- Initialize message list if p_init_msg_list is set to TRUE
5070: IF FND_API.To_Boolean(p_init_msg_list) THEN
5071: FND_MSG_PUB.initialize;
5072: END IF;
5073:
5074: -- Initialize API return status to success

Line 5075: l_return_status := FND_API.G_RET_STS_SUCCESS;

5071: FND_MSG_PUB.initialize;
5072: END IF;
5073:
5074: -- Initialize API return status to success
5075: l_return_status := FND_API.G_RET_STS_SUCCESS;
5076:
5077: -- START OF BODY OF API
5078: l_COMBINE_INT_WITH_LAST_PRIN := 'N';
5079:

Line 5275: RAISE FND_API.G_EXC_ERROR;

5271: FND_MESSAGE.SET_NAME('LNS', 'LNS_INVALID_VALUE');
5272: FND_MESSAGE.SET_TOKEN('PARAMETER', l_parameter);
5273: FND_MESSAGE.SET_TOKEN('VALUE', l_element);
5274: FND_MSG_PUB.ADD;
5275: RAISE FND_API.G_EXC_ERROR;
5276: END;
5277: end if;
5278:
5279: l_index := l_comma_index + 1;

Line 5288: RAISE FND_API.G_EXC_ERROR;

5284: if l_record_count = 0 then
5285: if l_date_pos is null then
5286: FND_MESSAGE.Set_Name('LNS', 'LNS_NO_DUE_DATE');
5287: FND_MSG_PUB.Add;
5288: RAISE FND_API.G_EXC_ERROR;
5289: end if;
5290: else
5291: if l_due_date is null then
5292: FND_MESSAGE.Set_Name('LNS', 'LNS_NO_DUE_DATE');

Line 5294: RAISE FND_API.G_EXC_ERROR;

5290: else
5291: if l_due_date is null then
5292: FND_MESSAGE.Set_Name('LNS', 'LNS_NO_DUE_DATE');
5293: FND_MSG_PUB.Add;
5294: RAISE FND_API.G_EXC_ERROR;
5295: else
5296:
5297: BEGIN
5298: -- testing date

Line 5396: if P_COMMIT = FND_API.G_TRUE then

5392: g_COMBINE_INT_WITH_LAST_PRIN := L_COMBINE_INT_WITH_LAST_PRIN;
5393: g_CUSTOM_SCHED_DESC := L_DESCRIPTION;
5394: end if;
5395:
5396: if P_COMMIT = FND_API.G_TRUE then
5397: COMMIT WORK;
5398: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Commited');
5399: end if;
5400:

Line 5402: x_return_status := FND_API.G_RET_STS_SUCCESS;

5398: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Commited');
5399: end if;
5400:
5401: -- END OF BODY OF API
5402: x_return_status := FND_API.G_RET_STS_SUCCESS;
5403:
5404: -- Standard call to get message count and if count is 1, get message info
5405: FND_MSG_PUB.Count_And_Get(
5406: p_encoded => FND_API.G_FALSE,

Line 5406: p_encoded => FND_API.G_FALSE,

5402: x_return_status := FND_API.G_RET_STS_SUCCESS;
5403:
5404: -- Standard call to get message count and if count is 1, get message info
5405: FND_MSG_PUB.Count_And_Get(
5406: p_encoded => FND_API.G_FALSE,
5407: p_count => x_msg_count,
5408: p_data => x_msg_data);
5409:
5410: LogMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, G_PKG_NAME || '.' || l_api_name || ' -');

Line 5415: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;

5411:
5412: EXCEPTION
5413: WHEN OTHERS THEN
5414: ROLLBACK TO parseClob;
5415: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
5416: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
5417: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');
5418: END;
5419:

Line 5450: x_return_status := FND_API.G_RET_STS_SUCCESS;

5446: g_CUSTOM_TBL := P_CUSTOM_TBL;
5447: G_AMORT_METHOD := P_CUSTOM_SET_REC.AMORT_METHOD;
5448: g_COMBINE_INT_WITH_LAST_PRIN := 'N';
5449: g_CUSTOM_SCHED_DESC := P_CUSTOM_SET_REC.DESCRIPTION;
5450: x_return_status := FND_API.G_RET_STS_SUCCESS;
5451:
5452: END;
5453:
5454:

Line 5481: x_return_status := FND_API.G_RET_STS_SUCCESS;

5477: g_CUSTOM_TBL.delete;
5478: G_AMORT_METHOD := null;
5479: g_COMBINE_INT_WITH_LAST_PRIN := null;
5480: g_CUSTOM_SCHED_DESC := null;
5481: x_return_status := FND_API.G_RET_STS_SUCCESS;
5482:
5483: END;
5484:
5485:

Line 5506: x_return_status := FND_API.G_RET_STS_SUCCESS;

5502:
5503: X_CUSTOM_SET_REC.AMORT_METHOD := G_AMORT_METHOD;
5504: X_CUSTOM_SET_REC.DESCRIPTION := g_CUSTOM_SCHED_DESC;
5505: X_CUSTOM_TBL := G_CUSTOM_TBL;
5506: x_return_status := FND_API.G_RET_STS_SUCCESS;
5507:
5508: END;
5509:
5510: