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 120: IF FND_API.to_Boolean( p_init_msg_list ) THEN

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

Line 125: x_return_status := FND_API.G_RET_STS_SUCCESS;

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

Line 140: if l_return_status <> FND_API.G_RET_STS_SUCCESS then

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

Line 145: RAISE FND_API.G_EXC_ERROR;

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

Line 159: RAISE FND_API.G_EXC_ERROR;

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

Line 172: RAISE FND_API.G_EXC_ERROR;

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

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

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

Line 204: IF FND_API.to_Boolean(p_commit) THEN

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

Line 213: WHEN FND_API.G_EXC_ERROR THEN

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

Line 215: x_return_status := FND_API.G_RET_STS_ERROR;

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

Line 221: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN

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

Line 223: x_return_status := FND_API.G_RET_STS_ERROR;

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

Line 231: x_return_status := FND_API.G_RET_STS_ERROR;

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

Line 323: IF FND_API.to_Boolean( p_init_msg_list ) THEN

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

Line 328: x_return_status := FND_API.G_RET_STS_SUCCESS;

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

Line 352: if l_return_status <> FND_API.G_RET_STS_SUCCESS then

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

Line 359: RAISE FND_API.G_EXC_ERROR;

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

Line 363: RAISE FND_API.G_EXC_ERROR;

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

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

504:
505: l_loan_header_rec.loan_id := p_loan_id;
506: l_loan_header_rec.CUSTOM_PAYMENTS_FLAG := 'Y';
507:
508: lns_loan_header_pub.update_loan(p_init_msg_list => FND_API.G_FALSE
509: ,p_loan_header_rec => l_loan_header_rec
510: ,P_OBJECT_VERSION_NUMBER => l_object_version
511: ,X_RETURN_STATUS => l_return_status
512: ,X_MSG_COUNT => l_msg_count

Line 519: if l_return_status <> FND_API.G_RET_STS_SUCCESS then

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

Line 523: RAISE FND_API.G_EXC_ERROR;

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

Line 526: IF FND_API.to_Boolean(p_commit)

522: FND_MSG_PUB.Add;
523: RAISE FND_API.G_EXC_ERROR;
524: end if;
525:
526: IF FND_API.to_Boolean(p_commit)
527: THEN
528: COMMIT WORK;
529: END IF;
530:

Line 537: WHEN FND_API.G_EXC_ERROR THEN

533:
534: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, l_api_name || ' - END');
535:
536: EXCEPTION
537: WHEN FND_API.G_EXC_ERROR THEN
538: FND_MESSAGE.Set_Name('LNS', 'LNS_CREATE_CUSTOM_ERROR');
539: FND_MSG_PUB.Add;
540: x_return_status := FND_API.G_RET_STS_ERROR;
541: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);

Line 540: x_return_status := FND_API.G_RET_STS_ERROR;

536: EXCEPTION
537: WHEN FND_API.G_EXC_ERROR THEN
538: FND_MESSAGE.Set_Name('LNS', 'LNS_CREATE_CUSTOM_ERROR');
539: FND_MSG_PUB.Add;
540: x_return_status := FND_API.G_RET_STS_ERROR;
541: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
542: ROLLBACK TO createCustomSchedule;
543:
544: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN

Line 544: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN

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

Line 547: x_return_status := FND_API.G_RET_STS_ERROR;

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

Line 554: x_return_status := FND_API.G_RET_STS_ERROR;

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

Line 639: IF FND_API.to_Boolean( p_init_msg_list ) THEN

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

Line 644: x_return_status := FND_API.G_RET_STS_SUCCESS;

640: FND_MSG_PUB.initialize;
641: END IF;
642:
643: -- Initialize API return status to SUCCESS
644: x_return_status := FND_API.G_RET_STS_SUCCESS;
645:
646: --
647: -- Api body
648: --

Line 679: if l_return_status <> FND_API.G_RET_STS_SUCCESS then

675: ,x_return_status => l_return_status
676: ,x_msg_count => l_msg_count
677: ,x_msg_data => l_msg_data);
678:
679: if l_return_status <> FND_API.G_RET_STS_SUCCESS then
680: if l_installment is not null then
681: X_INVALID_INSTALLMENT_NUM := l_installment;
682: FND_MESSAGE.Set_Name('LNS', 'LNS_INVALID_INSTALLMENT');
683: FND_MESSAGE.SET_TOKEN('PARAMETER', 'INSTALLMENT');

Line 686: RAISE FND_API.G_EXC_ERROR;

682: FND_MESSAGE.Set_Name('LNS', 'LNS_INVALID_INSTALLMENT');
683: FND_MESSAGE.SET_TOKEN('PARAMETER', 'INSTALLMENT');
684: FND_MESSAGE.SET_TOKEN('VALUE', l_installment);
685: FND_MSG_PUB.Add;
686: RAISE FND_API.G_EXC_ERROR;
687: end if;
688: FND_MESSAGE.Set_Name('LNS', 'LNS_VALIDATE_CUSTOM_ERROR');
689: FND_MSG_PUB.Add;
690: RAISE FND_API.G_EXC_ERROR;

Line 690: RAISE FND_API.G_EXC_ERROR;

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

Line 738: IF FND_API.to_Boolean(p_commit)

734: ,x_msg_data => l_msg_Data);
735:
736: end loop;
737:
738: IF FND_API.to_Boolean(p_commit)
739: THEN
740: COMMIT WORK;
741: END IF;
742:

Line 748: WHEN FND_API.G_EXC_ERROR THEN

744: p_data => x_msg_data);
745: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, l_api_name || ' - END');
746:
747: EXCEPTION
748: WHEN FND_API.G_EXC_ERROR THEN
749: --FND_MESSAGE.Set_Name('LNS', 'LNS_UPDATE_CUSTOM_ERROR');
750: --FND_MSG_PUB.Add;
751: --RAISE FND_API.G_EXC_ERROR;
752: x_return_status := FND_API.G_RET_STS_ERROR;

Line 751: --RAISE FND_API.G_EXC_ERROR;

747: EXCEPTION
748: WHEN FND_API.G_EXC_ERROR THEN
749: --FND_MESSAGE.Set_Name('LNS', 'LNS_UPDATE_CUSTOM_ERROR');
750: --FND_MSG_PUB.Add;
751: --RAISE FND_API.G_EXC_ERROR;
752: x_return_status := FND_API.G_RET_STS_ERROR;
753: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
754: ROLLBACK TO updateCustomSchedule;
755:

Line 752: x_return_status := FND_API.G_RET_STS_ERROR;

748: WHEN FND_API.G_EXC_ERROR THEN
749: --FND_MESSAGE.Set_Name('LNS', 'LNS_UPDATE_CUSTOM_ERROR');
750: --FND_MSG_PUB.Add;
751: --RAISE FND_API.G_EXC_ERROR;
752: x_return_status := FND_API.G_RET_STS_ERROR;
753: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
754: ROLLBACK TO updateCustomSchedule;
755:
756: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN

Line 756: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN

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

Line 759: --RAISE FND_API.G_EXC_ERROR;

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

Line 760: x_return_status := FND_API.G_RET_STS_ERROR;

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

Line 767: --RAISE FND_API.G_EXC_ERROR;

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

Line 768: x_return_status := FND_API.G_RET_STS_ERROR;

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

Line 838: RAISE FND_API.G_EXC_ERROR;

834:
835: if l_loan_details.number_installments - l_count <> l_cust_tbl.count then
836: FND_MESSAGE.Set_Name('LNS', 'LNS_INVALID_NUM_ROWS');
837: FND_MSG_PUB.Add;
838: RAISE FND_API.G_EXC_ERROR;
839: end if;
840: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, 'passed update validation');
841: end if;
842:

Line 856: RAISE FND_API.G_EXC_ERROR;

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

Line 866: if l_return_status <> FND_API.G_RET_STS_SUCCESS then

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

Line 873: RAISE FND_API.G_EXC_ERROR;

869: FND_MESSAGE.Set_Name('LNS', 'LNS_INVALID_INSTALLMENT');
870: FND_MESSAGE.SET_TOKEN('PARAMETER', 'INSTALLMENT');
871: FND_MESSAGE.SET_TOKEN('VALUE', i);
872: FND_MSG_PUB.Add;
873: RAISE FND_API.G_EXC_ERROR;
874: end if;
875:
876: -- check for consecutive installments
877: if l_cust_tbl.exists(i+1) then

Line 882: RAISE FND_API.G_EXC_ERROR;

878: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, 'checking consecutive installments' || l_cust_tbl(i).payment_number || ' ' || l_cust_tbl(i+1).payment_number );
879: if l_cust_tbl(i).payment_number + 1 <> l_cust_tbl(i+1).payment_number then
880: FND_MESSAGE.Set_Name('LNS', 'LNS_NONSEQUENTIAL_INSTALLMENTS');
881: FND_MSG_PUB.Add;
882: RAISE FND_API.G_EXC_ERROR;
883: end if;
884: end if;
885:
886: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, 'date checking');

Line 898: RAISE FND_API.G_EXC_ERROR;

894: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, 'l_date is: ' || l_date);
895: if p_cust_tbl(i).due_date <= l_date then
896: FND_MESSAGE.Set_Name('LNS', 'LNS_NONSEQUENTIAL_DATES');
897: FND_MSG_PUB.Add;
898: RAISE FND_API.G_EXC_ERROR;
899: end if;
900: l_date := l_cust_tbl(i).due_date;
901:
902: end if;

Line 917: RAISE FND_API.G_EXC_ERROR;

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

Line 927: WHEN FND_API.G_EXC_ERROR THEN

923: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, l_api_name || ' - END');
924:
925: EXCEPTION
926:
927: WHEN FND_API.G_EXC_ERROR THEN
928: --FND_MESSAGE.Set_Name('LNS', 'LNS_VALIDATE_CUSTOM_ERROR');
929: --FND_MSG_PUB.Add;
930: x_return_status := FND_API.G_RET_STS_ERROR;
931: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);

Line 930: x_return_status := FND_API.G_RET_STS_ERROR;

926:
927: WHEN FND_API.G_EXC_ERROR THEN
928: --FND_MESSAGE.Set_Name('LNS', 'LNS_VALIDATE_CUSTOM_ERROR');
929: --FND_MSG_PUB.Add;
930: x_return_status := FND_API.G_RET_STS_ERROR;
931: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
932:
933: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
934: --FND_MESSAGE.Set_Name('LNS', 'LNS_VALIDATE_CUSTOM_ERROR');

Line 933: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN

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

Line 936: x_return_status := FND_API.G_RET_STS_ERROR;

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

Line 942: x_return_status := FND_API.G_RET_STS_ERROR;

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

Line 964: x_return_status := FND_API.G_RET_STS_SUCCESS;

960: l_api_name varchar2(30);
961:
962: BEGIN
963:
964: x_return_status := FND_API.G_RET_STS_SUCCESS;
965: l_api_name := 'validateCustRow';
966: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, l_api_name || ' validate One Row');
967: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, l_api_name || ' ' || p_custom_rec.PAYMENT_NUMBER );
968: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, l_api_name || ' ' || p_custom_rec.DUE_DATE );

Line 975: RAISE FND_API.G_EXC_ERROR;

971:
972: if p_custom_rec.due_Date is null then
973: FND_MESSAGE.Set_Name('LNS', 'LNS_NO_DUE_DATE');
974: FND_MSG_PUB.Add;
975: RAISE FND_API.G_EXC_ERROR;
976:
977: elsif p_custom_rec.payment_number is null or p_custom_rec.payment_number < 1 then
978: FND_MESSAGE.Set_Name('LNS', 'LNS_INVALID_PAYMENT_NUMBER');
979: FND_MSG_PUB.Add;

Line 980: RAISE FND_API.G_EXC_ERROR;

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

Line 985: RAISE FND_API.G_EXC_ERROR;

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

Line 990: RAISE FND_API.G_EXC_ERROR;

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

Line 995: RAISE FND_API.G_EXC_ERROR;

991:
992: elsif p_custom_rec.FEE_AMOUNT is not null and p_custom_rec.FEE_AMOUNT < 0 then
993: FND_MESSAGE.Set_Name('LNS', 'LNS_OTHER_AMOUNT_ERROR');
994: FND_MSG_PUB.Add;
995: RAISE FND_API.G_EXC_ERROR;
996:
997: elsif p_custom_rec.OTHER_AMOUNT is not null and p_custom_rec.OTHER_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.OTHER_AMOUNT is not null and p_custom_rec.OTHER_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: end if;
1003:
1004: EXCEPTION

Line 1006: WHEN FND_API.G_EXC_ERROR THEN

1002: end if;
1003:
1004: EXCEPTION
1005:
1006: WHEN FND_API.G_EXC_ERROR THEN
1007: x_return_status := FND_API.G_RET_STS_ERROR;
1008: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
1009:
1010: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN

Line 1007: x_return_status := FND_API.G_RET_STS_ERROR;

1003:
1004: EXCEPTION
1005:
1006: WHEN FND_API.G_EXC_ERROR THEN
1007: x_return_status := FND_API.G_RET_STS_ERROR;
1008: logMessage(FND_LOG.LEVEL_ERROR, G_PKG_NAME, sqlerrm);
1009:
1010: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
1011: x_return_status := FND_API.G_RET_STS_ERROR;

Line 1010: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN

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

Line 1011: x_return_status := FND_API.G_RET_STS_ERROR;

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

Line 1015: x_return_status := FND_API.G_RET_STS_ERROR;

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

Line 1075: x_return_status := FND_API.G_RET_STS_SUCCESS;

1071: ,p_LOCK_PRIN => P_CUSTOM_REC.LOCK_PRIN
1072: ,p_LOCK_INT => P_CUSTOM_REC.LOCK_INT);
1073:
1074: x_custom_sched_id := l_custom_id;
1075: x_return_status := FND_API.G_RET_STS_SUCCESS;
1076:
1077: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, 'In createCustomSched: After call Insert_Row ID' || l_Custom_id );
1078:
1079: END createCustomSched;

Line 1143: x_return_status := FND_API.G_RET_STS_SUCCESS;

1139: ,p_ATTRIBUTE20 => P_CUSTOM_REC.ATTRIBUTE20
1140: ,p_LOCK_PRIN => P_CUSTOM_REC.LOCK_PRIN
1141: ,p_LOCK_INT => P_CUSTOM_REC.LOCK_INT);
1142:
1143: x_return_status := FND_API.G_RET_STS_SUCCESS;
1144:
1145: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, 'In updateCustomSched: After call Insert_Row');
1146:
1147: END updateCustomSched;

Line 1180: RAISE FND_API.G_EXC_ERROR;

1176: -- LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'ERROR: Several installments have the same due date.');
1177: FND_MESSAGE.SET_NAME('LNS', 'LNS_DUE_DATE_DUPL');
1178: FND_MSG_PUB.Add;
1179: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
1180: RAISE FND_API.G_EXC_ERROR;
1181: end if;
1182: end loop;
1183: end loop;
1184: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Done sorting.');

Line 1616: RAISE FND_API.G_EXC_ERROR;

1612: When No_Data_Found then
1613: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, 'LOAN ID: ' || p_loan_id || ' not found');
1614: FND_MESSAGE.Set_Name('LNS', 'LNS_INVALID_LOAN_ID');
1615: FND_MSG_PUB.Add;
1616: RAISE FND_API.G_EXC_ERROR;
1617:
1618: When Others then
1619: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, 'Err: ' || sqlerrm);
1620: RAISE FND_API.G_EXC_ERROR;

Line 1620: RAISE FND_API.G_EXC_ERROR;

1616: RAISE FND_API.G_EXC_ERROR;
1617:
1618: When Others then
1619: logMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, 'Err: ' || sqlerrm);
1620: RAISE FND_API.G_EXC_ERROR;
1621:
1622: end getLoanDetails;
1623:
1624:

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

1686: SAVEPOINT loadCustomSchedule;
1687: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Savepoint is established');
1688:
1689: -- Standard call to check for call compatibility
1690: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version, l_api_name, G_PKG_NAME) THEN
1691: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
1692: END IF;
1693:
1694: -- Initialize message list if p_init_msg_list is set to TRUE

Line 1691: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;

1687: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Savepoint is established');
1688:
1689: -- Standard call to check for call compatibility
1690: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version, l_api_name, G_PKG_NAME) THEN
1691: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
1692: END IF;
1693:
1694: -- Initialize message list if p_init_msg_list is set to TRUE
1695: IF FND_API.To_Boolean(p_init_msg_list) THEN

Line 1695: IF FND_API.To_Boolean(p_init_msg_list) THEN

1691: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
1692: END IF;
1693:
1694: -- Initialize message list if p_init_msg_list is set to TRUE
1695: IF FND_API.To_Boolean(p_init_msg_list) THEN
1696: FND_MSG_PUB.initialize;
1697: END IF;
1698:
1699: -- Initialize API return status to success

Line 1700: l_return_status := FND_API.G_RET_STS_SUCCESS;

1696: FND_MSG_PUB.initialize;
1697: END IF;
1698:
1699: -- Initialize API return status to success
1700: l_return_status := FND_API.G_RET_STS_SUCCESS;
1701:
1702: -- START OF BODY OF API
1703:
1704: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Input:');

Line 1713: RAISE FND_API.G_EXC_ERROR;

1709: FND_MESSAGE.SET_NAME('LNS', 'LNS_INVALID_VALUE');
1710: FND_MESSAGE.SET_TOKEN('PARAMETER', 'LOAN_ID');
1711: FND_MESSAGE.SET_TOKEN('VALUE', P_LOAN_ID);
1712: FND_MSG_PUB.ADD;
1713: RAISE FND_API.G_EXC_ERROR;
1714: end if;
1715:
1716: if P_BASED_ON_TERMS is null then
1717: FND_MESSAGE.SET_NAME('LNS', 'LNS_INVALID_VALUE');

Line 1721: RAISE FND_API.G_EXC_ERROR;

1717: FND_MESSAGE.SET_NAME('LNS', 'LNS_INVALID_VALUE');
1718: FND_MESSAGE.SET_TOKEN('PARAMETER', 'BASED_ON_TERMS');
1719: FND_MESSAGE.SET_TOKEN('VALUE', P_BASED_ON_TERMS);
1720: FND_MSG_PUB.ADD;
1721: RAISE FND_API.G_EXC_ERROR;
1722: end if;
1723:
1724: l_loan_details := getLoanDetails(p_loan_Id => p_loan_id
1725: ,p_based_on_terms => p_based_on_terms);

Line 1735: P_INIT_MSG_LIST => FND_API.G_TRUE,

1731:
1732: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Calling LNS_FINANCIALS.runAmortization...');
1733: LNS_FINANCIALS.runAmortization(
1734: P_API_VERSION => 1.0,
1735: P_INIT_MSG_LIST => FND_API.G_TRUE,
1736: P_COMMIT => FND_API.G_FALSE,
1737: P_LOAN_ID => P_LOAN_ID,
1738: P_BASED_ON_TERMS => P_BASED_ON_TERMS,
1739: x_amort_tbl => l_amort_tbl,

Line 1736: P_COMMIT => FND_API.G_FALSE,

1732: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Calling LNS_FINANCIALS.runAmortization...');
1733: LNS_FINANCIALS.runAmortization(
1734: P_API_VERSION => 1.0,
1735: P_INIT_MSG_LIST => FND_API.G_TRUE,
1736: P_COMMIT => FND_API.G_FALSE,
1737: P_LOAN_ID => P_LOAN_ID,
1738: P_BASED_ON_TERMS => P_BASED_ON_TERMS,
1739: x_amort_tbl => l_amort_tbl,
1740: x_return_status => l_return_status,

Line 1745: RAISE FND_API.G_EXC_ERROR;

1741: x_msg_count => l_msg_count,
1742: x_msg_data => l_msg_data);
1743:
1744: IF l_return_status <> 'S' THEN
1745: RAISE FND_API.G_EXC_ERROR;
1746: END IF;
1747:
1748: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Schedule from LNS_FINANCIALS.runAmortization:');
1749: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'PN DD PRIN LP INT LI FEE OTH ID');

Line 1828: P_INIT_MSG_LIST => FND_API.G_TRUE,

1824:
1825: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Recalculating schedule...');
1826: LNS_CUSTOM_PUB.recalcCustomSchedule(
1827: P_API_VERSION => 1.0,
1828: P_INIT_MSG_LIST => FND_API.G_TRUE,
1829: P_COMMIT => FND_API.G_FALSE,
1830: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,
1831: P_LOAN_ID => P_LOAN_ID,
1832: P_AMORT_METHOD => l_loan_details.CUSTOM_CALC_METHOD,

Line 1829: P_COMMIT => FND_API.G_FALSE,

1825: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Recalculating schedule...');
1826: LNS_CUSTOM_PUB.recalcCustomSchedule(
1827: P_API_VERSION => 1.0,
1828: P_INIT_MSG_LIST => FND_API.G_TRUE,
1829: P_COMMIT => FND_API.G_FALSE,
1830: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,
1831: P_LOAN_ID => P_LOAN_ID,
1832: P_AMORT_METHOD => l_loan_details.CUSTOM_CALC_METHOD,
1833: P_BASED_ON_TERMS => P_BASED_ON_TERMS,

Line 1830: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,

1826: LNS_CUSTOM_PUB.recalcCustomSchedule(
1827: P_API_VERSION => 1.0,
1828: P_INIT_MSG_LIST => FND_API.G_TRUE,
1829: P_COMMIT => FND_API.G_FALSE,
1830: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,
1831: P_LOAN_ID => P_LOAN_ID,
1832: P_AMORT_METHOD => l_loan_details.CUSTOM_CALC_METHOD,
1833: P_BASED_ON_TERMS => P_BASED_ON_TERMS,
1834: P_CUSTOM_TBL => l_custom_tbl,

Line 1840: RAISE FND_API.G_EXC_ERROR;

1836: x_msg_count => l_msg_count,
1837: x_msg_data => l_msg_data);
1838:
1839: IF l_return_status <> 'S' THEN
1840: RAISE FND_API.G_EXC_ERROR;
1841: END IF;
1842:
1843: if P_COMMIT = FND_API.G_TRUE then
1844: COMMIT WORK;

Line 1843: if P_COMMIT = FND_API.G_TRUE then

1839: IF l_return_status <> 'S' THEN
1840: RAISE FND_API.G_EXC_ERROR;
1841: END IF;
1842:
1843: if P_COMMIT = FND_API.G_TRUE then
1844: COMMIT WORK;
1845: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Commited');
1846: end if;
1847:

Line 1852: x_return_status := FND_API.G_RET_STS_SUCCESS;

1848: X_CUSTOM_TBL := l_CUSTOM_TBL;
1849: X_AMORT_METHOD := l_loan_details.CUSTOM_CALC_METHOD;
1850:
1851: -- END OF BODY OF API
1852: x_return_status := FND_API.G_RET_STS_SUCCESS;
1853:
1854: -- Standard call to get message count and if count is 1, get message info
1855: FND_MSG_PUB.Count_And_Get(
1856: p_encoded => FND_API.G_FALSE,

Line 1856: p_encoded => FND_API.G_FALSE,

1852: x_return_status := FND_API.G_RET_STS_SUCCESS;
1853:
1854: -- Standard call to get message count and if count is 1, get message info
1855: FND_MSG_PUB.Count_And_Get(
1856: p_encoded => FND_API.G_FALSE,
1857: p_count => x_msg_count,
1858: p_data => x_msg_data);
1859:
1860: LogMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, G_PKG_NAME || '.' || l_api_name || ' -');

Line 1863: WHEN FND_API.G_EXC_ERROR THEN

1859:
1860: LogMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, G_PKG_NAME || '.' || l_api_name || ' -');
1861:
1862: EXCEPTION
1863: WHEN FND_API.G_EXC_ERROR THEN
1864: ROLLBACK TO loadCustomSchedule;
1865: x_return_status := FND_API.G_RET_STS_ERROR;
1866: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
1867: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');

Line 1865: x_return_status := FND_API.G_RET_STS_ERROR;

1861:
1862: EXCEPTION
1863: WHEN FND_API.G_EXC_ERROR THEN
1864: ROLLBACK TO loadCustomSchedule;
1865: x_return_status := FND_API.G_RET_STS_ERROR;
1866: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
1867: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');
1868: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
1869: ROLLBACK TO loadCustomSchedule;

Line 1868: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN

1864: ROLLBACK TO loadCustomSchedule;
1865: x_return_status := FND_API.G_RET_STS_ERROR;
1866: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
1867: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');
1868: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
1869: ROLLBACK TO loadCustomSchedule;
1870: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
1871: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
1872: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');

Line 1870: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;

1866: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
1867: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');
1868: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
1869: ROLLBACK TO loadCustomSchedule;
1870: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
1871: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
1872: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');
1873: WHEN OTHERS THEN
1874: ROLLBACK TO loadCustomSchedule;

Line 1875: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;

1871: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
1872: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');
1873: WHEN OTHERS THEN
1874: ROLLBACK TO loadCustomSchedule;
1875: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
1876: IF FND_MSG_PUB.Check_Msg_Level(FND_MSG_PUB.G_MSG_LVL_UNEXP_ERROR)THEN
1877: FND_MSG_PUB.Add_Exc_Msg(G_PKG_NAME, l_api_name);
1878: END IF;
1879: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);

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

2008: SAVEPOINT recalcCustomSchedule;
2009: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Savepoint is established');
2010:
2011: -- Standard call to check for call compatibility
2012: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version, l_api_name, G_PKG_NAME) THEN
2013: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
2014: END IF;
2015:
2016: -- Initialize message list if p_init_msg_list is set to TRUE

Line 2013: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;

2009: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Savepoint is established');
2010:
2011: -- Standard call to check for call compatibility
2012: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version, l_api_name, G_PKG_NAME) THEN
2013: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
2014: END IF;
2015:
2016: -- Initialize message list if p_init_msg_list is set to TRUE
2017: IF FND_API.To_Boolean(p_init_msg_list) THEN

Line 2017: IF FND_API.To_Boolean(p_init_msg_list) THEN

2013: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
2014: END IF;
2015:
2016: -- Initialize message list if p_init_msg_list is set to TRUE
2017: IF FND_API.To_Boolean(p_init_msg_list) THEN
2018: FND_MSG_PUB.initialize;
2019: END IF;
2020:
2021: -- Initialize API return status to success

Line 2022: l_return_status := FND_API.G_RET_STS_SUCCESS;

2018: FND_MSG_PUB.initialize;
2019: END IF;
2020:
2021: -- Initialize API return status to success
2022: l_return_status := FND_API.G_RET_STS_SUCCESS;
2023:
2024: -- START OF BODY OF API
2025:
2026: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Input:');

Line 2036: RAISE FND_API.G_EXC_ERROR;

2032: FND_MESSAGE.SET_NAME('LNS', 'LNS_INVALID_VALUE');
2033: FND_MESSAGE.SET_TOKEN('PARAMETER', 'LOAN_ID');
2034: FND_MESSAGE.SET_TOKEN('VALUE', P_LOAN_ID);
2035: FND_MSG_PUB.ADD;
2036: RAISE FND_API.G_EXC_ERROR;
2037: end if;
2038:
2039: if P_BASED_ON_TERMS is null then
2040: FND_MESSAGE.SET_NAME('LNS', 'LNS_INVALID_VALUE');

Line 2044: RAISE FND_API.G_EXC_ERROR;

2040: FND_MESSAGE.SET_NAME('LNS', 'LNS_INVALID_VALUE');
2041: FND_MESSAGE.SET_TOKEN('PARAMETER', 'BASED_ON_TERMS');
2042: FND_MESSAGE.SET_TOKEN('VALUE', P_BASED_ON_TERMS);
2043: FND_MSG_PUB.ADD;
2044: RAISE FND_API.G_EXC_ERROR;
2045: end if;
2046:
2047: if P_AMORT_METHOD is null then
2048: FND_MESSAGE.SET_NAME('LNS', 'LNS_INVALID_VALUE');

Line 2052: RAISE FND_API.G_EXC_ERROR;

2048: FND_MESSAGE.SET_NAME('LNS', 'LNS_INVALID_VALUE');
2049: FND_MESSAGE.SET_TOKEN('PARAMETER', 'AMORT_METHOD');
2050: FND_MESSAGE.SET_TOKEN('VALUE', P_AMORT_METHOD);
2051: FND_MSG_PUB.ADD;
2052: RAISE FND_API.G_EXC_ERROR;
2053: end if;
2054:
2055: l_CUSTOM_TBL := P_CUSTOM_TBL;
2056:

Line 2089: RAISE FND_API.G_EXC_ERROR;

2085: -- LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'ERROR: Custom amortization is empty.');
2086: FND_MESSAGE.SET_NAME('LNS', 'LNS_CUST_AMORT_EMPTY');
2087: FND_MSG_PUB.Add;
2088: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
2089: RAISE FND_API.G_EXC_ERROR;
2090: */
2091: end if;
2092:
2093: l_loan_details := getLoanDetails(p_loan_Id => p_loan_id

Line 2139: RAISE FND_API.G_EXC_ERROR;

2135: -- LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'ERROR: Installment due date cannot be earlier then loan start date.');
2136: FND_MESSAGE.SET_NAME('LNS', 'LNS_EARLIER_LN_START_DATE');
2137: FND_MSG_PUB.Add;
2138: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
2139: RAISE FND_API.G_EXC_ERROR;
2140: end if;
2141:
2142: if l_loan_details.LAST_DUE_DATE is not null then
2143: if l_custom_tbl(i).DUE_DATE <= l_loan_details.LAST_DUE_DATE then

Line 2148: RAISE FND_API.G_EXC_ERROR;

2144: -- LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'ERROR: Installment due date cannot be earlier or equal to due date of the last billed installment.');
2145: FND_MESSAGE.SET_NAME('LNS', 'LNS_EARLIER_LAST_BILLED_DD');
2146: FND_MSG_PUB.Add;
2147: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
2148: RAISE FND_API.G_EXC_ERROR;
2149: end if;
2150: end if;
2151:
2152: if l_custom_tbl(i).DUE_DATE > l_loan_details.maturity_Date then

Line 2161: RAISE FND_API.G_EXC_ERROR;

2157: -- LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'ERROR: Installment due date cannot be later then loan maturity date.');
2158: FND_MESSAGE.SET_NAME('LNS', 'LNS_LATER_LN_MATUR_DATE');
2159: FND_MSG_PUB.Add;
2160: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
2161: RAISE FND_API.G_EXC_ERROR;
2162: end if;
2163:
2164: end if;
2165:

Line 2313: RAISE FND_API.G_EXC_ERROR;

2309: FND_MESSAGE.SET_NAME('LNS', 'LNS_RATES_ERROR');
2310: FND_MSG_PUB.ADD;
2311: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, l_api_name || ': rates missing for INDEX_ID ' || l_loan_details.TERM_INDEX_RATE_ID);
2312: logMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, l_api_name || ': rates missing for DATE ' || l_loan_details.NEXT_RATE_CHANGE_DATE);
2313: RAISE FND_API.G_EXC_ERROR;
2314: end if;
2315:
2316: -- add the spread into the rate
2317: l_raw_rate := l_rate_details.ANNUAL_RATE + l_rate_details.spread;

Line 2766: if P_COMMIT = FND_API.G_TRUE then

2762: end loop;
2763:
2764: P_CUSTOM_TBL := l_CUSTOM_TBL;
2765:
2766: if P_COMMIT = FND_API.G_TRUE then
2767: COMMIT WORK;
2768: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Commited');
2769: end if;
2770:

Line 2772: x_return_status := FND_API.G_RET_STS_SUCCESS;

2768: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Commited');
2769: end if;
2770:
2771: -- END OF BODY OF API
2772: x_return_status := FND_API.G_RET_STS_SUCCESS;
2773:
2774: -- Standard call to get message count and if count is 1, get message info
2775: FND_MSG_PUB.Count_And_Get(
2776: p_encoded => FND_API.G_FALSE,

Line 2776: p_encoded => FND_API.G_FALSE,

2772: x_return_status := FND_API.G_RET_STS_SUCCESS;
2773:
2774: -- Standard call to get message count and if count is 1, get message info
2775: FND_MSG_PUB.Count_And_Get(
2776: p_encoded => FND_API.G_FALSE,
2777: p_count => x_msg_count,
2778: p_data => x_msg_data);
2779:
2780: LogMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, G_PKG_NAME || '.' || l_api_name || ' -');

Line 2783: WHEN FND_API.G_EXC_ERROR THEN

2779:
2780: LogMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, G_PKG_NAME || '.' || l_api_name || ' -');
2781:
2782: EXCEPTION
2783: WHEN FND_API.G_EXC_ERROR THEN
2784: ROLLBACK TO recalcCustomSchedule;
2785: x_return_status := FND_API.G_RET_STS_ERROR;
2786: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
2787: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');

Line 2785: x_return_status := FND_API.G_RET_STS_ERROR;

2781:
2782: EXCEPTION
2783: WHEN FND_API.G_EXC_ERROR THEN
2784: ROLLBACK TO recalcCustomSchedule;
2785: x_return_status := FND_API.G_RET_STS_ERROR;
2786: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
2787: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');
2788: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
2789: ROLLBACK TO recalcCustomSchedule;

Line 2788: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN

2784: ROLLBACK TO recalcCustomSchedule;
2785: x_return_status := FND_API.G_RET_STS_ERROR;
2786: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
2787: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');
2788: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
2789: ROLLBACK TO recalcCustomSchedule;
2790: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
2791: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
2792: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');

Line 2790: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;

2786: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
2787: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');
2788: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
2789: ROLLBACK TO recalcCustomSchedule;
2790: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
2791: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
2792: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');
2793: WHEN OTHERS THEN
2794: ROLLBACK TO recalcCustomSchedule;

Line 2795: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;

2791: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
2792: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');
2793: WHEN OTHERS THEN
2794: ROLLBACK TO recalcCustomSchedule;
2795: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
2796: IF FND_MSG_PUB.Check_Msg_Level(FND_MSG_PUB.G_MSG_LVL_UNEXP_ERROR)THEN
2797: FND_MSG_PUB.Add_Exc_Msg(G_PKG_NAME, l_api_name);
2798: END IF;
2799: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);

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

2851: SAVEPOINT saveCustomSchedule;
2852: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Savepoint is established');
2853:
2854: -- Standard call to check for call compatibility
2855: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version, l_api_name, G_PKG_NAME) THEN
2856: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
2857: END IF;
2858:
2859: -- Initialize message list if p_init_msg_list is set to TRUE

Line 2856: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;

2852: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Savepoint is established');
2853:
2854: -- Standard call to check for call compatibility
2855: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version, l_api_name, G_PKG_NAME) THEN
2856: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
2857: END IF;
2858:
2859: -- Initialize message list if p_init_msg_list is set to TRUE
2860: IF FND_API.To_Boolean(p_init_msg_list) THEN

Line 2860: IF FND_API.To_Boolean(p_init_msg_list) THEN

2856: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
2857: END IF;
2858:
2859: -- Initialize message list if p_init_msg_list is set to TRUE
2860: IF FND_API.To_Boolean(p_init_msg_list) THEN
2861: FND_MSG_PUB.initialize;
2862: END IF;
2863:
2864: -- Initialize API return status to success

Line 2865: l_return_status := FND_API.G_RET_STS_SUCCESS;

2861: FND_MSG_PUB.initialize;
2862: END IF;
2863:
2864: -- Initialize API return status to success
2865: l_return_status := FND_API.G_RET_STS_SUCCESS;
2866:
2867: -- START OF BODY OF API
2868:
2869: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Input:');

Line 2879: RAISE FND_API.G_EXC_ERROR;

2875: FND_MESSAGE.SET_NAME('LNS', 'LNS_INVALID_VALUE');
2876: FND_MESSAGE.SET_TOKEN('PARAMETER', 'LOAN_ID');
2877: FND_MESSAGE.SET_TOKEN('VALUE', P_LOAN_ID);
2878: FND_MSG_PUB.ADD;
2879: RAISE FND_API.G_EXC_ERROR;
2880: end if;
2881:
2882: if P_BASED_ON_TERMS is null then
2883: FND_MESSAGE.SET_NAME('LNS', 'LNS_INVALID_VALUE');

Line 2887: RAISE FND_API.G_EXC_ERROR;

2883: FND_MESSAGE.SET_NAME('LNS', 'LNS_INVALID_VALUE');
2884: FND_MESSAGE.SET_TOKEN('PARAMETER', 'BASED_ON_TERMS');
2885: FND_MESSAGE.SET_TOKEN('VALUE', P_BASED_ON_TERMS);
2886: FND_MSG_PUB.ADD;
2887: RAISE FND_API.G_EXC_ERROR;
2888: end if;
2889:
2890: if P_AMORT_METHOD is null then
2891: FND_MESSAGE.SET_NAME('LNS', 'LNS_INVALID_VALUE');

Line 2895: RAISE FND_API.G_EXC_ERROR;

2891: FND_MESSAGE.SET_NAME('LNS', 'LNS_INVALID_VALUE');
2892: FND_MESSAGE.SET_TOKEN('PARAMETER', 'AMORT_METHOD');
2893: FND_MESSAGE.SET_TOKEN('VALUE', P_AMORT_METHOD);
2894: FND_MSG_PUB.ADD;
2895: RAISE FND_API.G_EXC_ERROR;
2896: end if;
2897:
2898: l_CUSTOM_TBL := P_CUSTOM_TBL;
2899:

Line 2902: P_INIT_MSG_LIST => FND_API.G_TRUE,

2898: l_CUSTOM_TBL := P_CUSTOM_TBL;
2899:
2900: LNS_CUSTOM_PUB.recalcCustomSchedule(
2901: P_API_VERSION => 1.0,
2902: P_INIT_MSG_LIST => FND_API.G_TRUE,
2903: P_COMMIT => FND_API.G_FALSE,
2904: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,
2905: P_LOAN_ID => P_LOAN_ID,
2906: P_AMORT_METHOD => P_AMORT_METHOD,

Line 2903: P_COMMIT => FND_API.G_FALSE,

2899:
2900: LNS_CUSTOM_PUB.recalcCustomSchedule(
2901: P_API_VERSION => 1.0,
2902: P_INIT_MSG_LIST => FND_API.G_TRUE,
2903: P_COMMIT => FND_API.G_FALSE,
2904: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,
2905: P_LOAN_ID => P_LOAN_ID,
2906: P_AMORT_METHOD => P_AMORT_METHOD,
2907: P_BASED_ON_TERMS => P_BASED_ON_TERMS,

Line 2904: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,

2900: LNS_CUSTOM_PUB.recalcCustomSchedule(
2901: P_API_VERSION => 1.0,
2902: P_INIT_MSG_LIST => FND_API.G_TRUE,
2903: P_COMMIT => FND_API.G_FALSE,
2904: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,
2905: P_LOAN_ID => P_LOAN_ID,
2906: P_AMORT_METHOD => P_AMORT_METHOD,
2907: P_BASED_ON_TERMS => P_BASED_ON_TERMS,
2908: P_CUSTOM_TBL => l_custom_tbl,

Line 2914: RAISE FND_API.G_EXC_ERROR;

2910: x_msg_count => l_msg_count,
2911: x_msg_data => l_msg_data);
2912:
2913: IF l_return_status <> 'S' THEN
2914: RAISE FND_API.G_EXC_ERROR;
2915: END IF;
2916:
2917: l_loan_details := getLoanDetails(p_loan_Id => p_loan_id
2918: ,p_based_on_terms => P_BASED_ON_TERMS);

Line 2948: RAISE FND_API.G_EXC_ERROR;

2944: ,x_msg_count => l_msg_Count
2945: ,x_msg_data => l_msg_Data);
2946:
2947: IF l_return_status <> 'S' THEN
2948: RAISE FND_API.G_EXC_ERROR;
2949: END IF;
2950:
2951: elsif l_custom_tbl(i).ACTION = 'I' then
2952:

Line 2961: RAISE FND_API.G_EXC_ERROR;

2957: ,x_msg_count => l_msg_Count
2958: ,x_msg_data => l_msg_Data);
2959:
2960: IF l_return_status <> 'S' THEN
2961: RAISE FND_API.G_EXC_ERROR;
2962: END IF;
2963:
2964: l_custom_tbl(i).CUSTOM_SCHEDULE_ID := l_custom_sched_id;
2965:

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

2992: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Updating lns_loan_headers_all');
2993: l_loan_header_rec.loan_id := P_LOAN_ID;
2994: l_loan_header_rec.CUSTOM_PAYMENTS_FLAG := 'Y';
2995:
2996: lns_loan_header_pub.update_loan(p_init_msg_list => FND_API.G_TRUE
2997: ,p_loan_header_rec => l_loan_header_rec
2998: ,P_OBJECT_VERSION_NUMBER => l_object_version
2999: ,X_RETURN_STATUS => l_return_status
3000: ,X_MSG_COUNT => l_msg_count

Line 3011: RAISE FND_API.G_EXC_ERROR;

3007: ELSE
3008: FND_MESSAGE.SET_NAME('LNS', 'LNS_UPD_LOAN_FAIL');
3009: FND_MSG_PUB.Add;
3010: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
3011: RAISE FND_API.G_EXC_ERROR;
3012: end if;
3013: end if;
3014:
3015: -- getting terms version for future update

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

3027:
3028: if l_loan_details.loan_status <> 'INCOMPLETE' and l_loan_details.CUSTOM_SCHEDULE = 'N' then
3029: l_term_rec.ORIG_PAY_CALC_METHOD := l_loan_details.PAYMENT_CALC_METHOD;
3030: elsif l_loan_details.loan_status = 'INCOMPLETE' then
3031: l_term_rec.ORIG_PAY_CALC_METHOD := FND_API.G_MISS_CHAR;
3032: end if;
3033:
3034: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'CUSTOM_CALC_METHOD: ' || l_term_rec.CUSTOM_CALC_METHOD);
3035:

Line 3037: p_init_msg_list => FND_API.G_FALSE,

3033:
3034: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'CUSTOM_CALC_METHOD: ' || l_term_rec.CUSTOM_CALC_METHOD);
3035:
3036: LNS_TERMS_PUB.update_term(P_OBJECT_VERSION_NUMBER => l_object_version,
3037: p_init_msg_list => FND_API.G_FALSE,
3038: p_loan_term_rec => l_term_rec,
3039: X_RETURN_STATUS => l_return_status,
3040: X_MSG_COUNT => l_msg_count,
3041: X_MSG_DATA => l_msg_data);

Line 3052: RAISE FND_API.G_EXC_ERROR;

3048: -- LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'ERROR: LNS_TERMS_PUB.update_term returned error: ' || substr(l_msg_data,1,225));
3049: FND_MESSAGE.SET_NAME('LNS', 'LNS_UPD_TERM_FAIL');
3050: FND_MSG_PUB.Add;
3051: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
3052: RAISE FND_API.G_EXC_ERROR;
3053: END IF;
3054:
3055: -- getting number of installments and synching rate schedule
3056: l_num_installments := l_custom_tbl(l_custom_tbl.count).PAYMENT_NUMBER;

Line 3059: if P_COMMIT = FND_API.G_TRUE then

3055: -- getting number of installments and synching rate schedule
3056: l_num_installments := l_custom_tbl(l_custom_tbl.count).PAYMENT_NUMBER;
3057: synchRateSchedule(l_term_id, l_num_installments);
3058:
3059: if P_COMMIT = FND_API.G_TRUE then
3060: COMMIT WORK;
3061: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Commited');
3062: end if;
3063:

Line 3067: x_return_status := FND_API.G_RET_STS_SUCCESS;

3063:
3064: P_CUSTOM_TBL := l_CUSTOM_TBL;
3065:
3066: -- END OF BODY OF API
3067: x_return_status := FND_API.G_RET_STS_SUCCESS;
3068:
3069: -- Standard call to get message count and if count is 1, get message info
3070: FND_MSG_PUB.Count_And_Get(
3071: p_encoded => FND_API.G_FALSE,

Line 3071: p_encoded => FND_API.G_FALSE,

3067: x_return_status := FND_API.G_RET_STS_SUCCESS;
3068:
3069: -- Standard call to get message count and if count is 1, get message info
3070: FND_MSG_PUB.Count_And_Get(
3071: p_encoded => FND_API.G_FALSE,
3072: p_count => x_msg_count,
3073: p_data => x_msg_data);
3074:
3075: LogMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, G_PKG_NAME || '.' || l_api_name || ' -');

Line 3078: WHEN FND_API.G_EXC_ERROR THEN

3074:
3075: LogMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, G_PKG_NAME || '.' || l_api_name || ' -');
3076:
3077: EXCEPTION
3078: WHEN FND_API.G_EXC_ERROR THEN
3079: ROLLBACK TO saveCustomSchedule;
3080: x_return_status := FND_API.G_RET_STS_ERROR;
3081: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
3082: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');

Line 3080: x_return_status := FND_API.G_RET_STS_ERROR;

3076:
3077: EXCEPTION
3078: WHEN FND_API.G_EXC_ERROR THEN
3079: ROLLBACK TO saveCustomSchedule;
3080: x_return_status := FND_API.G_RET_STS_ERROR;
3081: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
3082: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');
3083: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
3084: ROLLBACK TO saveCustomSchedule;

Line 3083: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN

3079: ROLLBACK TO saveCustomSchedule;
3080: x_return_status := FND_API.G_RET_STS_ERROR;
3081: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
3082: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');
3083: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
3084: ROLLBACK TO saveCustomSchedule;
3085: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
3086: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
3087: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');

Line 3085: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;

3081: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
3082: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');
3083: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
3084: ROLLBACK TO saveCustomSchedule;
3085: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
3086: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
3087: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');
3088: WHEN OTHERS THEN
3089: ROLLBACK TO saveCustomSchedule;

Line 3090: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;

3086: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
3087: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');
3088: WHEN OTHERS THEN
3089: ROLLBACK TO saveCustomSchedule;
3090: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
3091: IF FND_MSG_PUB.Check_Msg_Level(FND_MSG_PUB.G_MSG_LVL_UNEXP_ERROR)THEN
3092: FND_MSG_PUB.Add_Exc_Msg(G_PKG_NAME, l_api_name);
3093: END IF;
3094: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);

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

3142: SAVEPOINT uncustomizeSchedule;
3143: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Savepoint is established');
3144:
3145: -- Standard call to check for call compatibility
3146: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version, l_api_name, G_PKG_NAME) THEN
3147: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
3148: END IF;
3149:
3150: -- Initialize message list if p_init_msg_list is set to TRUE

Line 3147: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;

3143: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Savepoint is established');
3144:
3145: -- Standard call to check for call compatibility
3146: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version, l_api_name, G_PKG_NAME) THEN
3147: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
3148: END IF;
3149:
3150: -- Initialize message list if p_init_msg_list is set to TRUE
3151: IF FND_API.To_Boolean(p_init_msg_list) THEN

Line 3151: IF FND_API.To_Boolean(p_init_msg_list) THEN

3147: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
3148: END IF;
3149:
3150: -- Initialize message list if p_init_msg_list is set to TRUE
3151: IF FND_API.To_Boolean(p_init_msg_list) THEN
3152: FND_MSG_PUB.initialize;
3153: END IF;
3154:
3155: -- Initialize API return status to success

Line 3156: l_return_status := FND_API.G_RET_STS_SUCCESS;

3152: FND_MSG_PUB.initialize;
3153: END IF;
3154:
3155: -- Initialize API return status to success
3156: l_return_status := FND_API.G_RET_STS_SUCCESS;
3157:
3158: -- START OF BODY OF API
3159:
3160: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Input:');

Line 3169: RAISE FND_API.G_EXC_ERROR;

3165: FND_MESSAGE.SET_NAME('LNS', 'LNS_INVALID_VALUE');
3166: FND_MESSAGE.SET_TOKEN('PARAMETER', 'LOAN_ID');
3167: FND_MESSAGE.SET_TOKEN('VALUE', P_LOAN_ID);
3168: FND_MSG_PUB.ADD;
3169: RAISE FND_API.G_EXC_ERROR;
3170: end if;
3171:
3172: l_BASED_ON_TERMS := 'ORIGINATION';
3173: l_loan_details := getLoanDetails(p_loan_Id => p_loan_id

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

3190: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Updating lns_loan_headers_all set custom = N');
3191: l_loan_header_rec.loan_id := P_LOAN_ID;
3192: l_loan_header_rec.CUSTOM_PAYMENTS_FLAG := 'N';
3193:
3194: lns_loan_header_pub.update_loan(p_init_msg_list => FND_API.G_TRUE
3195: ,p_loan_header_rec => l_loan_header_rec
3196: ,P_OBJECT_VERSION_NUMBER => l_object_version
3197: ,X_RETURN_STATUS => l_return_status
3198: ,X_MSG_COUNT => l_msg_count

Line 3209: RAISE FND_API.G_EXC_ERROR;

3205: ELSE
3206: FND_MESSAGE.SET_NAME('LNS', 'LNS_UPD_LOAN_FAIL');
3207: FND_MSG_PUB.Add;
3208: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
3209: RAISE FND_API.G_EXC_ERROR;
3210: end if;
3211:
3212: -- getting terms version for future update
3213: select term_id, object_version_number into l_term_id, l_object_version

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

3219:
3220: l_term_rec.TERM_ID := l_term_id;
3221: l_term_rec.LOAN_ID := p_loan_id;
3222: l_term_rec.PAYMENT_CALC_METHOD := P_ST_AMORT_METHOD;
3223: l_term_rec.CUSTOM_CALC_METHOD := FND_API.G_MISS_CHAR;
3224: l_term_rec.ORIG_PAY_CALC_METHOD := FND_API.G_MISS_CHAR;
3225:
3226: LNS_TERMS_PUB.update_term(P_OBJECT_VERSION_NUMBER => l_object_version,
3227: p_init_msg_list => FND_API.G_FALSE,

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

3220: l_term_rec.TERM_ID := l_term_id;
3221: l_term_rec.LOAN_ID := p_loan_id;
3222: l_term_rec.PAYMENT_CALC_METHOD := P_ST_AMORT_METHOD;
3223: l_term_rec.CUSTOM_CALC_METHOD := FND_API.G_MISS_CHAR;
3224: l_term_rec.ORIG_PAY_CALC_METHOD := FND_API.G_MISS_CHAR;
3225:
3226: LNS_TERMS_PUB.update_term(P_OBJECT_VERSION_NUMBER => l_object_version,
3227: p_init_msg_list => FND_API.G_FALSE,
3228: p_loan_term_rec => l_term_rec,

Line 3227: p_init_msg_list => FND_API.G_FALSE,

3223: l_term_rec.CUSTOM_CALC_METHOD := FND_API.G_MISS_CHAR;
3224: l_term_rec.ORIG_PAY_CALC_METHOD := FND_API.G_MISS_CHAR;
3225:
3226: LNS_TERMS_PUB.update_term(P_OBJECT_VERSION_NUMBER => l_object_version,
3227: p_init_msg_list => FND_API.G_FALSE,
3228: p_loan_term_rec => l_term_rec,
3229: X_RETURN_STATUS => l_return_status,
3230: X_MSG_COUNT => l_msg_count,
3231: X_MSG_DATA => l_msg_data);

Line 3242: RAISE FND_API.G_EXC_ERROR;

3238: -- LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'ERROR: LNS_TERMS_PUB.update_term returned error: ' || substr(l_msg_data,1,225));
3239: FND_MESSAGE.SET_NAME('LNS', 'LNS_UPD_TERM_FAIL');
3240: FND_MSG_PUB.Add;
3241: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
3242: RAISE FND_API.G_EXC_ERROR;
3243: END IF;
3244:
3245: -- synching rate schedule
3246: l_num_installments := LNS_FIN_UTILS.getNumberInstallments(p_loan_id);

Line 3253: if P_COMMIT = FND_API.G_TRUE then

3249: else
3250: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Nothing to update');
3251: end if;
3252:
3253: if P_COMMIT = FND_API.G_TRUE then
3254: COMMIT WORK;
3255: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Commited');
3256: end if;
3257:

Line 3259: x_return_status := FND_API.G_RET_STS_SUCCESS;

3255: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Commited');
3256: end if;
3257:
3258: -- END OF BODY OF API
3259: x_return_status := FND_API.G_RET_STS_SUCCESS;
3260:
3261: -- Standard call to get message count and if count is 1, get message info
3262: FND_MSG_PUB.Count_And_Get(
3263: p_encoded => FND_API.G_FALSE,

Line 3263: p_encoded => FND_API.G_FALSE,

3259: x_return_status := FND_API.G_RET_STS_SUCCESS;
3260:
3261: -- Standard call to get message count and if count is 1, get message info
3262: FND_MSG_PUB.Count_And_Get(
3263: p_encoded => FND_API.G_FALSE,
3264: p_count => x_msg_count,
3265: p_data => x_msg_data);
3266:
3267: LogMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, G_PKG_NAME || '.' || l_api_name || ' -');

Line 3270: WHEN FND_API.G_EXC_ERROR THEN

3266:
3267: LogMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, G_PKG_NAME || '.' || l_api_name || ' -');
3268:
3269: EXCEPTION
3270: WHEN FND_API.G_EXC_ERROR THEN
3271: ROLLBACK TO uncustomizeSchedule;
3272: x_return_status := FND_API.G_RET_STS_ERROR;
3273: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
3274: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');

Line 3272: x_return_status := FND_API.G_RET_STS_ERROR;

3268:
3269: EXCEPTION
3270: WHEN FND_API.G_EXC_ERROR THEN
3271: ROLLBACK TO uncustomizeSchedule;
3272: x_return_status := FND_API.G_RET_STS_ERROR;
3273: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
3274: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');
3275: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
3276: ROLLBACK TO uncustomizeSchedule;

Line 3275: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN

3271: ROLLBACK TO uncustomizeSchedule;
3272: x_return_status := FND_API.G_RET_STS_ERROR;
3273: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
3274: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');
3275: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
3276: ROLLBACK TO uncustomizeSchedule;
3277: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
3278: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
3279: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');

Line 3277: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;

3273: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
3274: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');
3275: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
3276: ROLLBACK TO uncustomizeSchedule;
3277: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
3278: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
3279: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');
3280: WHEN OTHERS THEN
3281: ROLLBACK TO uncustomizeSchedule;

Line 3282: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;

3278: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
3279: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');
3280: WHEN OTHERS THEN
3281: ROLLBACK TO uncustomizeSchedule;
3282: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
3283: IF FND_MSG_PUB.Check_Msg_Level(FND_MSG_PUB.G_MSG_LVL_UNEXP_ERROR)THEN
3284: FND_MSG_PUB.Add_Exc_Msg(G_PKG_NAME, l_api_name);
3285: END IF;
3286: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);

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

3329: SAVEPOINT customizeSchedule;
3330: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Savepoint is established');
3331:
3332: -- Standard call to check for call compatibility
3333: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version, l_api_name, G_PKG_NAME) THEN
3334: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
3335: END IF;
3336:
3337: -- Initialize message list if p_init_msg_list is set to TRUE

Line 3334: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;

3330: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Savepoint is established');
3331:
3332: -- Standard call to check for call compatibility
3333: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version, l_api_name, G_PKG_NAME) THEN
3334: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
3335: END IF;
3336:
3337: -- Initialize message list if p_init_msg_list is set to TRUE
3338: IF FND_API.To_Boolean(p_init_msg_list) THEN

Line 3338: IF FND_API.To_Boolean(p_init_msg_list) THEN

3334: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
3335: END IF;
3336:
3337: -- Initialize message list if p_init_msg_list is set to TRUE
3338: IF FND_API.To_Boolean(p_init_msg_list) THEN
3339: FND_MSG_PUB.initialize;
3340: END IF;
3341:
3342: -- Initialize API return status to success

Line 3343: l_return_status := FND_API.G_RET_STS_SUCCESS;

3339: FND_MSG_PUB.initialize;
3340: END IF;
3341:
3342: -- Initialize API return status to success
3343: l_return_status := FND_API.G_RET_STS_SUCCESS;
3344:
3345: -- START OF BODY OF API
3346:
3347: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Input:');

Line 3355: RAISE FND_API.G_EXC_ERROR;

3351: FND_MESSAGE.SET_NAME('LNS', 'LNS_INVALID_VALUE');
3352: FND_MESSAGE.SET_TOKEN('PARAMETER', 'LOAN_ID');
3353: FND_MESSAGE.SET_TOKEN('VALUE', P_LOAN_ID);
3354: FND_MSG_PUB.ADD;
3355: RAISE FND_API.G_EXC_ERROR;
3356: end if;
3357:
3358: l_BASED_ON_TERMS := 'ORIGINATION';
3359: l_loan_details := getLoanDetails(p_loan_Id => p_loan_id

Line 3368: P_INIT_MSG_LIST => FND_API.G_TRUE,

3364:
3365: -- load initial schedule
3366: LNS_CUSTOM_PUB.loadCustomSchedule(
3367: P_API_VERSION => 1.0,
3368: P_INIT_MSG_LIST => FND_API.G_TRUE,
3369: P_COMMIT => FND_API.G_FALSE,
3370: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,
3371: P_LOAN_ID => P_LOAN_ID,
3372: P_BASED_ON_TERMS => l_BASED_ON_TERMS,

Line 3369: P_COMMIT => FND_API.G_FALSE,

3365: -- load initial schedule
3366: LNS_CUSTOM_PUB.loadCustomSchedule(
3367: P_API_VERSION => 1.0,
3368: P_INIT_MSG_LIST => FND_API.G_TRUE,
3369: P_COMMIT => FND_API.G_FALSE,
3370: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,
3371: P_LOAN_ID => P_LOAN_ID,
3372: P_BASED_ON_TERMS => l_BASED_ON_TERMS,
3373: X_AMORT_METHOD => l_AMORT_METHOD,

Line 3370: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,

3366: LNS_CUSTOM_PUB.loadCustomSchedule(
3367: P_API_VERSION => 1.0,
3368: P_INIT_MSG_LIST => FND_API.G_TRUE,
3369: P_COMMIT => FND_API.G_FALSE,
3370: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,
3371: P_LOAN_ID => P_LOAN_ID,
3372: P_BASED_ON_TERMS => l_BASED_ON_TERMS,
3373: X_AMORT_METHOD => l_AMORT_METHOD,
3374: X_CUSTOM_TBL => l_custom_tbl,

Line 3380: RAISE FND_API.G_EXC_ERROR;

3376: x_msg_count => l_msg_count,
3377: x_msg_data => l_msg_data);
3378:
3379: IF l_return_status <> 'S' THEN
3380: RAISE FND_API.G_EXC_ERROR;
3381: END IF;
3382:
3383: -- immediatly save it
3384: LNS_CUSTOM_PUB.saveCustomSchedule(

Line 3386: P_INIT_MSG_LIST => FND_API.G_TRUE,

3382:
3383: -- immediatly save it
3384: LNS_CUSTOM_PUB.saveCustomSchedule(
3385: P_API_VERSION => 1.0,
3386: P_INIT_MSG_LIST => FND_API.G_TRUE,
3387: P_COMMIT => FND_API.G_FALSE,
3388: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,
3389: P_LOAN_ID => P_LOAN_ID,
3390: P_BASED_ON_TERMS => l_BASED_ON_TERMS,

Line 3387: P_COMMIT => FND_API.G_FALSE,

3383: -- immediatly save it
3384: LNS_CUSTOM_PUB.saveCustomSchedule(
3385: P_API_VERSION => 1.0,
3386: P_INIT_MSG_LIST => FND_API.G_TRUE,
3387: P_COMMIT => FND_API.G_FALSE,
3388: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,
3389: P_LOAN_ID => P_LOAN_ID,
3390: P_BASED_ON_TERMS => l_BASED_ON_TERMS,
3391: P_AMORT_METHOD => l_AMORT_METHOD,

Line 3388: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,

3384: LNS_CUSTOM_PUB.saveCustomSchedule(
3385: P_API_VERSION => 1.0,
3386: P_INIT_MSG_LIST => FND_API.G_TRUE,
3387: P_COMMIT => FND_API.G_FALSE,
3388: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,
3389: P_LOAN_ID => P_LOAN_ID,
3390: P_BASED_ON_TERMS => l_BASED_ON_TERMS,
3391: P_AMORT_METHOD => l_AMORT_METHOD,
3392: P_CUSTOM_TBL => l_custom_tbl,

Line 3398: RAISE FND_API.G_EXC_ERROR;

3394: x_msg_count => l_msg_count,
3395: x_msg_data => l_msg_data);
3396:
3397: IF l_return_status <> 'S' THEN
3398: RAISE FND_API.G_EXC_ERROR;
3399: END IF;
3400:
3401: end if;
3402:

Line 3403: if P_COMMIT = FND_API.G_TRUE then

3399: END IF;
3400:
3401: end if;
3402:
3403: if P_COMMIT = FND_API.G_TRUE then
3404: COMMIT WORK;
3405: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Commited');
3406: end if;
3407:

Line 3409: x_return_status := FND_API.G_RET_STS_SUCCESS;

3405: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Commited');
3406: end if;
3407:
3408: -- END OF BODY OF API
3409: x_return_status := FND_API.G_RET_STS_SUCCESS;
3410:
3411: -- Standard call to get message count and if count is 1, get message info
3412: FND_MSG_PUB.Count_And_Get(
3413: p_encoded => FND_API.G_FALSE,

Line 3413: p_encoded => FND_API.G_FALSE,

3409: x_return_status := FND_API.G_RET_STS_SUCCESS;
3410:
3411: -- Standard call to get message count and if count is 1, get message info
3412: FND_MSG_PUB.Count_And_Get(
3413: p_encoded => FND_API.G_FALSE,
3414: p_count => x_msg_count,
3415: p_data => x_msg_data);
3416:
3417: LogMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, G_PKG_NAME || '.' || l_api_name || ' -');

Line 3420: WHEN FND_API.G_EXC_ERROR THEN

3416:
3417: LogMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, G_PKG_NAME || '.' || l_api_name || ' -');
3418:
3419: EXCEPTION
3420: WHEN FND_API.G_EXC_ERROR THEN
3421: ROLLBACK TO customizeSchedule;
3422: x_return_status := FND_API.G_RET_STS_ERROR;
3423: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
3424: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');

Line 3422: x_return_status := FND_API.G_RET_STS_ERROR;

3418:
3419: EXCEPTION
3420: WHEN FND_API.G_EXC_ERROR THEN
3421: ROLLBACK TO customizeSchedule;
3422: x_return_status := FND_API.G_RET_STS_ERROR;
3423: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
3424: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');
3425: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
3426: ROLLBACK TO customizeSchedule;

Line 3425: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN

3421: ROLLBACK TO customizeSchedule;
3422: x_return_status := FND_API.G_RET_STS_ERROR;
3423: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
3424: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');
3425: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
3426: ROLLBACK TO customizeSchedule;
3427: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
3428: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
3429: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');

Line 3427: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;

3423: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
3424: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');
3425: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
3426: ROLLBACK TO customizeSchedule;
3427: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
3428: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
3429: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');
3430: WHEN OTHERS THEN
3431: ROLLBACK TO customizeSchedule;

Line 3432: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;

3428: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
3429: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');
3430: WHEN OTHERS THEN
3431: ROLLBACK TO customizeSchedule;
3432: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
3433: IF FND_MSG_PUB.Check_Msg_Level(FND_MSG_PUB.G_MSG_LVL_UNEXP_ERROR)THEN
3434: FND_MSG_PUB.Add_Exc_Msg(G_PKG_NAME, l_api_name);
3435: END IF;
3436: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);

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

3564: SAVEPOINT shiftCustomSchedule;
3565: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Savepoint is established');
3566:
3567: -- Standard call to check for call compatibility
3568: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version, l_api_name, G_PKG_NAME) THEN
3569: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
3570: END IF;
3571:
3572: -- Initialize message list if p_init_msg_list is set to TRUE

Line 3569: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;

3565: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Savepoint is established');
3566:
3567: -- Standard call to check for call compatibility
3568: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version, l_api_name, G_PKG_NAME) THEN
3569: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
3570: END IF;
3571:
3572: -- Initialize message list if p_init_msg_list is set to TRUE
3573: IF FND_API.To_Boolean(p_init_msg_list) THEN

Line 3573: IF FND_API.To_Boolean(p_init_msg_list) THEN

3569: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
3570: END IF;
3571:
3572: -- Initialize message list if p_init_msg_list is set to TRUE
3573: IF FND_API.To_Boolean(p_init_msg_list) THEN
3574: FND_MSG_PUB.initialize;
3575: END IF;
3576:
3577: -- Initialize API return status to success

Line 3578: l_return_status := FND_API.G_RET_STS_SUCCESS;

3574: FND_MSG_PUB.initialize;
3575: END IF;
3576:
3577: -- Initialize API return status to success
3578: l_return_status := FND_API.G_RET_STS_SUCCESS;
3579:
3580: -- START OF BODY OF API
3581:
3582: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Input:');

Line 3594: RAISE FND_API.G_EXC_ERROR;

3590: FND_MESSAGE.SET_NAME('LNS', 'LNS_INVALID_VALUE');
3591: FND_MESSAGE.SET_TOKEN('PARAMETER', 'LOAN_ID');
3592: FND_MESSAGE.SET_TOKEN('VALUE', P_LOAN_ID);
3593: FND_MSG_PUB.ADD;
3594: RAISE FND_API.G_EXC_ERROR;
3595: end if;
3596:
3597: if P_BASED_ON_TERMS is null then
3598: FND_MESSAGE.SET_NAME('LNS', 'LNS_INVALID_VALUE');

Line 3602: RAISE FND_API.G_EXC_ERROR;

3598: FND_MESSAGE.SET_NAME('LNS', 'LNS_INVALID_VALUE');
3599: FND_MESSAGE.SET_TOKEN('PARAMETER', 'BASED_ON_TERMS');
3600: FND_MESSAGE.SET_TOKEN('VALUE', P_BASED_ON_TERMS);
3601: FND_MSG_PUB.ADD;
3602: RAISE FND_API.G_EXC_ERROR;
3603: end if;
3604:
3605: if P_AMORT_METHOD is null then
3606: FND_MESSAGE.SET_NAME('LNS', 'LNS_INVALID_VALUE');

Line 3610: RAISE FND_API.G_EXC_ERROR;

3606: FND_MESSAGE.SET_NAME('LNS', 'LNS_INVALID_VALUE');
3607: FND_MESSAGE.SET_TOKEN('PARAMETER', 'AMORT_METHOD');
3608: FND_MESSAGE.SET_TOKEN('VALUE', P_AMORT_METHOD);
3609: FND_MSG_PUB.ADD;
3610: RAISE FND_API.G_EXC_ERROR;
3611: end if;
3612:
3613: if P_NEW_DUE_DATE is null then
3614: FND_MESSAGE.SET_NAME('LNS', 'LNS_INVALID_VALUE');

Line 3618: RAISE FND_API.G_EXC_ERROR;

3614: FND_MESSAGE.SET_NAME('LNS', 'LNS_INVALID_VALUE');
3615: FND_MESSAGE.SET_TOKEN('PARAMETER', 'NEW_DUE_DATE');
3616: FND_MESSAGE.SET_TOKEN('VALUE', P_NEW_DUE_DATE);
3617: FND_MSG_PUB.ADD;
3618: RAISE FND_API.G_EXC_ERROR;
3619: end if;
3620:
3621: l_CUSTOM_TBL := P_CUSTOM_TBL;
3622:

Line 3629: RAISE FND_API.G_EXC_ERROR;

3625: -- LogMessage(FND_LOG.LEVEL_UNEXPECTED, 'ERROR: Custom amortization is empty.');
3626: FND_MESSAGE.SET_NAME('LNS', 'LNS_CUST_AMORT_EMPTY');
3627: FND_MSG_PUB.Add;
3628: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
3629: RAISE FND_API.G_EXC_ERROR;
3630: end if;
3631:
3632: l_return := shiftRowsByDate(P_OLD_DUE_DATE => P_OLD_DUE_DATE,
3633: P_NEW_DUE_DATE => P_NEW_DUE_DATE,

Line 3642: P_INIT_MSG_LIST => FND_API.G_TRUE,

3638: end if;
3639:
3640: LNS_CUSTOM_PUB.recalcCustomSchedule(
3641: P_API_VERSION => 1.0,
3642: P_INIT_MSG_LIST => FND_API.G_TRUE,
3643: P_COMMIT => FND_API.G_FALSE,
3644: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,
3645: P_LOAN_ID => P_LOAN_ID,
3646: P_AMORT_METHOD => P_AMORT_METHOD,

Line 3643: P_COMMIT => FND_API.G_FALSE,

3639:
3640: LNS_CUSTOM_PUB.recalcCustomSchedule(
3641: P_API_VERSION => 1.0,
3642: P_INIT_MSG_LIST => FND_API.G_TRUE,
3643: P_COMMIT => FND_API.G_FALSE,
3644: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,
3645: P_LOAN_ID => P_LOAN_ID,
3646: P_AMORT_METHOD => P_AMORT_METHOD,
3647: P_BASED_ON_TERMS => P_BASED_ON_TERMS,

Line 3644: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,

3640: LNS_CUSTOM_PUB.recalcCustomSchedule(
3641: P_API_VERSION => 1.0,
3642: P_INIT_MSG_LIST => FND_API.G_TRUE,
3643: P_COMMIT => FND_API.G_FALSE,
3644: P_VALIDATION_LEVEL => FND_API.G_VALID_LEVEL_FULL,
3645: P_LOAN_ID => P_LOAN_ID,
3646: P_AMORT_METHOD => P_AMORT_METHOD,
3647: P_BASED_ON_TERMS => P_BASED_ON_TERMS,
3648: P_CUSTOM_TBL => l_custom_tbl,

Line 3654: RAISE FND_API.G_EXC_ERROR;

3650: x_msg_count => l_msg_count,
3651: x_msg_data => l_msg_data);
3652:
3653: IF l_return_status <> 'S' THEN
3654: RAISE FND_API.G_EXC_ERROR;
3655: END IF;
3656:
3657: P_CUSTOM_TBL := l_CUSTOM_TBL;
3658:

Line 3659: if P_COMMIT = FND_API.G_TRUE then

3655: END IF;
3656:
3657: P_CUSTOM_TBL := l_CUSTOM_TBL;
3658:
3659: if P_COMMIT = FND_API.G_TRUE then
3660: COMMIT WORK;
3661: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Commited');
3662: end if;
3663:

Line 3665: x_return_status := FND_API.G_RET_STS_SUCCESS;

3661: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Commited');
3662: end if;
3663:
3664: -- END OF BODY OF API
3665: x_return_status := FND_API.G_RET_STS_SUCCESS;
3666:
3667: -- Standard call to get message count and if count is 1, get message info
3668: FND_MSG_PUB.Count_And_Get(
3669: p_encoded => FND_API.G_FALSE,

Line 3669: p_encoded => FND_API.G_FALSE,

3665: x_return_status := FND_API.G_RET_STS_SUCCESS;
3666:
3667: -- Standard call to get message count and if count is 1, get message info
3668: FND_MSG_PUB.Count_And_Get(
3669: p_encoded => FND_API.G_FALSE,
3670: p_count => x_msg_count,
3671: p_data => x_msg_data);
3672:
3673: LogMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, G_PKG_NAME || '.' || l_api_name || ' -');

Line 3676: WHEN FND_API.G_EXC_ERROR THEN

3672:
3673: LogMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, G_PKG_NAME || '.' || l_api_name || ' -');
3674:
3675: EXCEPTION
3676: WHEN FND_API.G_EXC_ERROR THEN
3677: ROLLBACK TO shiftCustomSchedule;
3678: x_return_status := FND_API.G_RET_STS_ERROR;
3679: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
3680: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');

Line 3678: x_return_status := FND_API.G_RET_STS_ERROR;

3674:
3675: EXCEPTION
3676: WHEN FND_API.G_EXC_ERROR THEN
3677: ROLLBACK TO shiftCustomSchedule;
3678: x_return_status := FND_API.G_RET_STS_ERROR;
3679: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
3680: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');
3681: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
3682: ROLLBACK TO shiftCustomSchedule;

Line 3681: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN

3677: ROLLBACK TO shiftCustomSchedule;
3678: x_return_status := FND_API.G_RET_STS_ERROR;
3679: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
3680: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');
3681: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
3682: ROLLBACK TO shiftCustomSchedule;
3683: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
3684: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
3685: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');

Line 3683: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;

3679: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
3680: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');
3681: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
3682: ROLLBACK TO shiftCustomSchedule;
3683: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
3684: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
3685: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');
3686: WHEN OTHERS THEN
3687: ROLLBACK TO shiftCustomSchedule;

Line 3688: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;

3684: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
3685: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');
3686: WHEN OTHERS THEN
3687: ROLLBACK TO shiftCustomSchedule;
3688: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
3689: IF FND_MSG_PUB.Check_Msg_Level(FND_MSG_PUB.G_MSG_LVL_UNEXP_ERROR)THEN
3690: FND_MSG_PUB.Add_Exc_Msg(G_PKG_NAME, l_api_name);
3691: END IF;
3692: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);

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

3737: SAVEPOINT reBuildCustomdSchedule;
3738: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Savepoint is established');
3739:
3740: -- Standard call to check for call compatibility
3741: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version, l_api_name, G_PKG_NAME) THEN
3742: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
3743: END IF;
3744:
3745: -- Initialize message list if p_init_msg_list is set to TRUE

Line 3742: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;

3738: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Savepoint is established');
3739:
3740: -- Standard call to check for call compatibility
3741: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version, l_api_name, G_PKG_NAME) THEN
3742: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
3743: END IF;
3744:
3745: -- Initialize message list if p_init_msg_list is set to TRUE
3746: IF FND_API.To_Boolean(p_init_msg_list) THEN

Line 3746: IF FND_API.To_Boolean(p_init_msg_list) THEN

3742: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
3743: END IF;
3744:
3745: -- Initialize message list if p_init_msg_list is set to TRUE
3746: IF FND_API.To_Boolean(p_init_msg_list) THEN
3747: FND_MSG_PUB.initialize;
3748: END IF;
3749:
3750: -- Initialize API return status to success

Line 3751: l_return_status := FND_API.G_RET_STS_SUCCESS;

3747: FND_MSG_PUB.initialize;
3748: END IF;
3749:
3750: -- Initialize API return status to success
3751: l_return_status := FND_API.G_RET_STS_SUCCESS;
3752:
3753: -- START OF BODY OF API
3754:
3755: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Input:');

Line 3763: RAISE FND_API.G_EXC_ERROR;

3759: FND_MESSAGE.SET_NAME('LNS', 'LNS_INVALID_VALUE');
3760: FND_MESSAGE.SET_TOKEN('PARAMETER', 'LOAN_ID');
3761: FND_MESSAGE.SET_TOKEN('VALUE', P_LOAN_ID);
3762: FND_MSG_PUB.ADD;
3763: RAISE FND_API.G_EXC_ERROR;
3764: end if;
3765:
3766: l_BASED_ON_TERMS := 'ORIGINATION';
3767: l_loan_details := getLoanDetails(p_loan_Id => p_loan_id

Line 3786: if P_COMMIT = FND_API.G_TRUE then

3782: else
3783: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Nothing to update');
3784: end if;
3785:
3786: if P_COMMIT = FND_API.G_TRUE then
3787: COMMIT WORK;
3788: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Commited');
3789: end if;
3790:

Line 3792: x_return_status := FND_API.G_RET_STS_SUCCESS;

3788: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Commited');
3789: end if;
3790:
3791: -- END OF BODY OF API
3792: x_return_status := FND_API.G_RET_STS_SUCCESS;
3793:
3794: -- Standard call to get message count and if count is 1, get message info
3795: FND_MSG_PUB.Count_And_Get(
3796: p_encoded => FND_API.G_FALSE,

Line 3796: p_encoded => FND_API.G_FALSE,

3792: x_return_status := FND_API.G_RET_STS_SUCCESS;
3793:
3794: -- Standard call to get message count and if count is 1, get message info
3795: FND_MSG_PUB.Count_And_Get(
3796: p_encoded => FND_API.G_FALSE,
3797: p_count => x_msg_count,
3798: p_data => x_msg_data);
3799:
3800: LogMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, G_PKG_NAME || '.' || l_api_name || ' -');

Line 3803: WHEN FND_API.G_EXC_ERROR THEN

3799:
3800: LogMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, G_PKG_NAME || '.' || l_api_name || ' -');
3801:
3802: EXCEPTION
3803: WHEN FND_API.G_EXC_ERROR THEN
3804: ROLLBACK TO reBuildCustomdSchedule;
3805: x_return_status := FND_API.G_RET_STS_ERROR;
3806: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
3807: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');

Line 3805: x_return_status := FND_API.G_RET_STS_ERROR;

3801:
3802: EXCEPTION
3803: WHEN FND_API.G_EXC_ERROR THEN
3804: ROLLBACK TO reBuildCustomdSchedule;
3805: x_return_status := FND_API.G_RET_STS_ERROR;
3806: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
3807: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');
3808: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
3809: ROLLBACK TO reBuildCustomdSchedule;

Line 3808: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN

3804: ROLLBACK TO reBuildCustomdSchedule;
3805: x_return_status := FND_API.G_RET_STS_ERROR;
3806: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
3807: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');
3808: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
3809: ROLLBACK TO reBuildCustomdSchedule;
3810: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
3811: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
3812: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');

Line 3810: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;

3806: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
3807: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');
3808: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
3809: ROLLBACK TO reBuildCustomdSchedule;
3810: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
3811: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
3812: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');
3813: WHEN OTHERS THEN
3814: ROLLBACK TO reBuildCustomdSchedule;

Line 3815: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;

3811: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
3812: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');
3813: WHEN OTHERS THEN
3814: ROLLBACK TO reBuildCustomdSchedule;
3815: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
3816: IF FND_MSG_PUB.Check_Msg_Level(FND_MSG_PUB.G_MSG_LVL_UNEXP_ERROR)THEN
3817: FND_MSG_PUB.Add_Exc_Msg(G_PKG_NAME, l_api_name);
3818: END IF;
3819: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);

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

3979: SAVEPOINT addMissingInstallment;
3980: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Savepoint is established');
3981:
3982: -- Standard call to check for call compatibility
3983: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version, l_api_name, G_PKG_NAME) THEN
3984: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
3985: END IF;
3986:
3987: -- Initialize message list if p_init_msg_list is set to TRUE

Line 3984: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;

3980: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Savepoint is established');
3981:
3982: -- Standard call to check for call compatibility
3983: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version, l_api_name, G_PKG_NAME) THEN
3984: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
3985: END IF;
3986:
3987: -- Initialize message list if p_init_msg_list is set to TRUE
3988: IF FND_API.To_Boolean(p_init_msg_list) THEN

Line 3988: IF FND_API.To_Boolean(p_init_msg_list) THEN

3984: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
3985: END IF;
3986:
3987: -- Initialize message list if p_init_msg_list is set to TRUE
3988: IF FND_API.To_Boolean(p_init_msg_list) THEN
3989: FND_MSG_PUB.initialize;
3990: END IF;
3991:
3992: -- Initialize API return status to success

Line 3993: X_RETURN_STATUS := FND_API.G_RET_STS_SUCCESS;

3989: FND_MSG_PUB.initialize;
3990: END IF;
3991:
3992: -- Initialize API return status to success
3993: X_RETURN_STATUS := FND_API.G_RET_STS_SUCCESS;
3994:
3995: -- START OF BODY OF API
3996: l_INSTALLMENT_REC := P_INSTALLMENT_REC;
3997:

Line 4015: RAISE FND_API.G_EXC_ERROR;

4011: FND_MESSAGE.SET_TOKEN('PARAMETER', 'LOAN_ID');
4012: FND_MESSAGE.SET_TOKEN('VALUE', l_INSTALLMENT_REC.LOAN_ID);
4013: FND_MSG_PUB.ADD;
4014: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
4015: RAISE FND_API.G_EXC_ERROR;
4016: end if;
4017:
4018: if l_INSTALLMENT_REC.PAYMENT_NUMBER is null then
4019: FND_MESSAGE.SET_NAME('LNS', 'LNS_INVALID_VALUE');

Line 4024: RAISE FND_API.G_EXC_ERROR;

4020: FND_MESSAGE.SET_TOKEN('PARAMETER', 'PAYMENT_NUMBER');
4021: FND_MESSAGE.SET_TOKEN('VALUE', l_INSTALLMENT_REC.PAYMENT_NUMBER);
4022: FND_MSG_PUB.ADD;
4023: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
4024: RAISE FND_API.G_EXC_ERROR;
4025: end if;
4026:
4027: if l_INSTALLMENT_REC.DUE_DATE is null then
4028: FND_MESSAGE.SET_NAME('LNS', 'LNS_INVALID_VALUE');

Line 4033: RAISE FND_API.G_EXC_ERROR;

4029: FND_MESSAGE.SET_TOKEN('PARAMETER', 'DUE_DATE');
4030: FND_MESSAGE.SET_TOKEN('VALUE', l_INSTALLMENT_REC.DUE_DATE);
4031: FND_MSG_PUB.ADD;
4032: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, FND_MSG_PUB.Get(p_encoded => 'F'));
4033: RAISE FND_API.G_EXC_ERROR;
4034: end if;
4035:
4036: open c_exist_installment(l_INSTALLMENT_REC.LOAN_ID, l_INSTALLMENT_REC.PAYMENT_NUMBER);
4037: fetch c_exist_installment into l_custom_sched_id;

Line 4086: RAISE FND_API.G_EXC_ERROR;

4082: ,x_msg_data => l_msg_Data);
4083:
4084: IF l_return_status <> 'S' THEN
4085: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Failed to insert custom schedule row');
4086: RAISE FND_API.G_EXC_ERROR;
4087: END IF;
4088:
4089: if P_COMMIT = FND_API.G_TRUE then
4090: COMMIT WORK;

Line 4089: if P_COMMIT = FND_API.G_TRUE then

4085: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Failed to insert custom schedule row');
4086: RAISE FND_API.G_EXC_ERROR;
4087: END IF;
4088:
4089: if P_COMMIT = FND_API.G_TRUE then
4090: COMMIT WORK;
4091: LogMessage(FND_LOG.LEVEL_STATEMENT, G_PKG_NAME, 'Commited');
4092: end if;
4093:

Line 4097: x_return_status := FND_API.G_RET_STS_SUCCESS;

4093:
4094: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Successfully added installment ' || l_INSTALLMENT_REC.PAYMENT_NUMBER || ' to custom schedule');
4095:
4096: -- END OF BODY OF API
4097: x_return_status := FND_API.G_RET_STS_SUCCESS;
4098:
4099: -- Standard call to get message count and if count is 1, get message info
4100: FND_MSG_PUB.Count_And_Get(
4101: p_encoded => FND_API.G_FALSE,

Line 4101: p_encoded => FND_API.G_FALSE,

4097: x_return_status := FND_API.G_RET_STS_SUCCESS;
4098:
4099: -- Standard call to get message count and if count is 1, get message info
4100: FND_MSG_PUB.Count_And_Get(
4101: p_encoded => FND_API.G_FALSE,
4102: p_count => x_msg_count,
4103: p_data => x_msg_data);
4104:
4105: LogMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, G_PKG_NAME || '.' || l_api_name || ' -');

Line 4108: WHEN FND_API.G_EXC_ERROR THEN

4104:
4105: LogMessage(FND_LOG.LEVEL_PROCEDURE, G_PKG_NAME, G_PKG_NAME || '.' || l_api_name || ' -');
4106:
4107: EXCEPTION
4108: WHEN FND_API.G_EXC_ERROR THEN
4109: ROLLBACK TO addMissingInstallment;
4110: x_return_status := FND_API.G_RET_STS_ERROR;
4111: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
4112: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');

Line 4110: x_return_status := FND_API.G_RET_STS_ERROR;

4106:
4107: EXCEPTION
4108: WHEN FND_API.G_EXC_ERROR THEN
4109: ROLLBACK TO addMissingInstallment;
4110: x_return_status := FND_API.G_RET_STS_ERROR;
4111: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
4112: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');
4113: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
4114: ROLLBACK TO addMissingInstallment;

Line 4113: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN

4109: ROLLBACK TO addMissingInstallment;
4110: x_return_status := FND_API.G_RET_STS_ERROR;
4111: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
4112: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');
4113: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
4114: ROLLBACK TO addMissingInstallment;
4115: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
4116: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
4117: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');

Line 4115: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;

4111: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
4112: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');
4113: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
4114: ROLLBACK TO addMissingInstallment;
4115: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
4116: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
4117: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');
4118: WHEN OTHERS THEN
4119: ROLLBACK TO addMissingInstallment;

Line 4120: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;

4116: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);
4117: LogMessage(FND_LOG.LEVEL_UNEXPECTED, G_PKG_NAME, 'Rollbacked');
4118: WHEN OTHERS THEN
4119: ROLLBACK TO addMissingInstallment;
4120: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
4121: IF FND_MSG_PUB.Check_Msg_Level(FND_MSG_PUB.G_MSG_LVL_UNEXP_ERROR)THEN
4122: FND_MSG_PUB.Add_Exc_Msg(G_PKG_NAME, l_api_name);
4123: END IF;
4124: FND_MSG_PUB.Count_And_Get(p_count => x_msg_count, p_data => x_msg_data);