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.OKL_PAYMENT_APPLICATION_PVT dependencies on OKC_API

Line 116: x_return_status := OKC_API.G_RET_STS_SUCCESS;

112: BEGIN
113: IF (G_DEBUG_ENABLED = 'Y') THEN
114: G_IS_DEBUG_STATEMENT_ON := OKL_DEBUG_PUB.CHECK_LOG_ON(G_MODULE, FND_LOG.LEVEL_STATEMENT);
115: END IF;
116: x_return_status := OKC_API.G_RET_STS_SUCCESS;
117: IF (G_IS_DEBUG_STATEMENT_ON = true) THEN
118: OKL_DEBUG_PUB.LOG_DEBUG(FND_LOG.LEVEL_STATEMENT, G_MODULE,l_proc_name);
119: END IF;
120: OPEN lrule_csr(p_chr_id,

Line 136: x_return_status := OKC_API.G_RET_STS_ERROR;

132: WHEN OTHERS THEN
133: IF lrule_csr%ISOPEN THEN
134: CLOSE lrule_csr;
135: END IF;
136: x_return_status := OKC_API.G_RET_STS_ERROR;
137: okl_api.set_message(
138: G_APP_NAME,
139: G_UNEXPECTED_ERROR,
140: 'OKL_SQLCODE',

Line 203: x_return_status := OKC_API.G_RET_STS_SUCCESS;

199: BEGIN
200: IF (G_DEBUG_ENABLED = 'Y') THEN
201: G_IS_DEBUG_STATEMENT_ON := OKL_DEBUG_PUB.CHECK_LOG_ON(G_MODULE, FND_LOG.LEVEL_STATEMENT);
202: END IF;
203: x_return_status := OKC_API.G_RET_STS_SUCCESS;
204: IF (G_IS_DEBUG_STATEMENT_ON = true) THEN
205: OKL_DEBUG_PUB.LOG_DEBUG(FND_LOG.LEVEL_STATEMENT, G_MODULE,l_proc_name);
206: END IF;
207: OPEN l_ro_sl_rule_csr(p_chr_id, p_cle_id,

Line 227: x_return_status := OKC_API.G_RET_STS_ERROR;

223: WHEN OTHERS THEN
224: IF l_ro_sl_rule_csr%ISOPEN THEN
225: CLOSE l_ro_sl_rule_csr;
226: END IF;
227: x_return_status := OKC_API.G_RET_STS_ERROR;
228: okl_api.set_message(
229: G_APP_NAME,
230: G_UNEXPECTED_ERROR,
231: 'OKL_SQLCODE',

Line 281: x_return_status := OKC_API.G_RET_STS_SUCCESS;

277: END IF;
278: IF (G_IS_DEBUG_STATEMENT_ON = true) THEN
279: OKL_DEBUG_PUB.LOG_DEBUG(FND_LOG.LEVEL_STATEMENT, G_MODULE,l_proc_name);
280: END IF;
281: x_return_status := OKC_API.G_RET_STS_SUCCESS;
282:
283: l_cap_amount := 0;
284: OPEN cap_csr(p_fin_line_id);
285: FETCH cap_csr INTO l_cap_amount;

Line 1082: x_return_status := OKC_API.G_RET_STS_SUCCESS;

1078: l_precision FND_CURRENCIES.PRECISION%TYPE;
1079:
1080: BEGIN
1081:
1082: x_return_status := OKC_API.G_RET_STS_SUCCESS;
1083: OPEN chr_csr(p_chr_id);
1084: FETCH chr_csr INTO l_currency_code;
1085: IF chr_csr%NOTFOUND THEN
1086: okl_api.set_message(

Line 1113: x_return_status := OKC_API.G_RET_STS_ERROR;

1109: RETURN;
1110:
1111: EXCEPTION
1112: WHEN curr_failed THEN
1113: x_return_status := OKC_API.G_RET_STS_ERROR;
1114: END get_currency_precision;
1115:
1116: ------------------------------------------------------------------------------
1117: -- PROCEDURE create_line_rule

Line 1190: x_return_status := OKC_API.G_RET_STS_SUCCESS;

1186: IF (G_IS_DEBUG_STATEMENT_ON = true) THEN
1187: OKL_DEBUG_PUB.LOG_DEBUG(FND_LOG.LEVEL_STATEMENT, G_MODULE,l_proc_name);
1188: END IF;
1189:
1190: x_return_status := OKC_API.G_RET_STS_SUCCESS;
1191:
1192: -- Check to see presence of LELEVL Rule Group at line
1193: l_rgp_id := NULL;
1194: OPEN rg_csr(p_chr_id,

Line 1219: p_init_msg_list => OKC_API.G_FALSE,

1215: l_rgpv_rec.dnz_chr_id := p_chr_id;
1216:
1217: OKL_RULE_PUB.create_rule_group(
1218: p_api_version => 1.0,
1219: p_init_msg_list => OKC_API.G_FALSE,
1220: x_return_status => x_return_status,
1221: x_msg_count => x_msg_count,
1222: x_msg_data => x_msg_data,
1223: p_rgpv_rec => l_rgpv_rec,

Line 1226: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN

1222: x_msg_data => x_msg_data,
1223: p_rgpv_rec => l_rgpv_rec,
1224: x_rgpv_rec => x_new_rgpv_rec
1225: );
1226: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1227: x_return_status := OKC_API.G_RET_STS_ERROR;
1228: raise rule_failed;
1229: END IF;
1230: ELSE

Line 1227: x_return_status := OKC_API.G_RET_STS_ERROR;

1223: p_rgpv_rec => l_rgpv_rec,
1224: x_rgpv_rec => x_new_rgpv_rec
1225: );
1226: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1227: x_return_status := OKC_API.G_RET_STS_ERROR;
1228: raise rule_failed;
1229: END IF;
1230: ELSE
1231: x_new_rgpv_rec.id := l_rgp_id;

Line 1245: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN

1241: x_msg_data => x_msg_data,
1242: x_rulv_tbl => x_slh_rulv_tbl,
1243: x_rule_count => x_slh_rule_count
1244: );
1245: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1246: RAISE rule_failed;
1247: END IF;
1248:
1249: IF (x_slh_rule_count = 0) THEN

Line 1266: p_init_msg_list => OKC_API.G_FALSE,

1262: l_slh_rulv_rec := x_slh_rulv_tbl(i);
1263: l_slh_rulv_rec.rgp_id := x_new_rgpv_rec.id;
1264: OKL_RULE_PUB.create_rule(
1265: p_api_version => 1.0,
1266: p_init_msg_list => OKC_API.G_FALSE,
1267: x_return_status => x_return_status,
1268: x_msg_count => x_msg_count,
1269: x_msg_data => x_msg_data,
1270: p_rulv_rec => l_slh_rulv_rec,

Line 1273: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN

1269: x_msg_data => x_msg_data,
1270: p_rulv_rec => l_slh_rulv_rec,
1271: x_rulv_rec => x_new_slh_rulv_rec
1272: );
1273: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1274: x_return_status := OKC_API.G_RET_STS_ERROR;
1275: raise rule_failed;
1276: END IF;
1277:

Line 1274: x_return_status := OKC_API.G_RET_STS_ERROR;

1270: p_rulv_rec => l_slh_rulv_rec,
1271: x_rulv_rec => x_new_slh_rulv_rec
1272: );
1273: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1274: x_return_status := OKC_API.G_RET_STS_ERROR;
1275: raise rule_failed;
1276: END IF;
1277:
1278: --okl_rule_apis_pvt.Get_Contract_Rules(

Line 1290: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN

1286: p_slh_id => x_slh_rulv_tbl(i).id,
1287: x_rulv_tbl => x_sll_rulv_tbl,
1288: x_rule_count => x_sll_rule_count
1289: );
1290: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1291: RAISE rule_failed;
1292: END IF;
1293:
1294: IF (x_sll_rule_count = 0) THEN

Line 1323: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN

1319: x_msg_data => x_msg_data,
1320: p_fin_line_id => p_cle_id,
1321: x_fee_cap_amt => l_fee_line_capital_amount
1322: );
1323: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1324: x_return_status := OKC_API.G_RET_STS_ERROR;
1325: raise rule_failed;
1326: END IF;
1327: END IF;

Line 1324: x_return_status := OKC_API.G_RET_STS_ERROR;

1320: p_fin_line_id => p_cle_id,
1321: x_fee_cap_amt => l_fee_line_capital_amount
1322: );
1323: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1324: x_return_status := OKC_API.G_RET_STS_ERROR;
1325: raise rule_failed;
1326: END IF;
1327: END IF;
1328:

Line 1353: p_init_msg_list => OKC_API.G_FALSE,

1349: l_sll_rulv_rec.object2_id1 := x_new_slh_rulv_rec.id;
1350:
1351: OKL_RULE_PUB.create_rule(
1352: p_api_version => 1.0,
1353: p_init_msg_list => OKC_API.G_FALSE,
1354: x_return_status => x_return_status,
1355: x_msg_count => x_msg_count,
1356: x_msg_data => x_msg_data,
1357: p_rulv_rec => l_sll_rulv_rec,

Line 1360: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN

1356: x_msg_data => x_msg_data,
1357: p_rulv_rec => l_sll_rulv_rec,
1358: x_rulv_rec => x_rulv_rec
1359: );
1360: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1361: x_return_status := OKC_API.G_RET_STS_ERROR;
1362: raise rule_failed;
1363: END IF;
1364: END LOOP; -- SLL

Line 1361: x_return_status := OKC_API.G_RET_STS_ERROR;

1357: p_rulv_rec => l_sll_rulv_rec,
1358: x_rulv_rec => x_rulv_rec
1359: );
1360: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1361: x_return_status := OKC_API.G_RET_STS_ERROR;
1362: raise rule_failed;
1363: END IF;
1364: END LOOP; -- SLL
1365:

Line 1372: x_return_status := OKC_API.G_RET_STS_ERROR;

1368: RETURN;
1369:
1370: EXCEPTION
1371: WHEN rule_failed THEN
1372: x_return_status := OKC_API.G_RET_STS_ERROR;
1373: WHEN OTHERS THEN
1374: okl_api.set_message(
1375: G_APP_NAME,
1376: G_UNEXPECTED_ERROR,

Line 1382: x_return_status := OKC_API.G_RET_STS_ERROR;

1378: SQLCODE,
1379: 'OKL_SQLERRM',
1380: SQLERRM || ': '||G_PKG_NAME||'.'||l_proc_name
1381: );
1382: x_return_status := OKC_API.G_RET_STS_ERROR;
1383: END create_line_rule;
1384:
1385:
1386: ------------------------------------------------------------------------------

Line 1414: x_return_status := OKC_API.G_RET_STS_SUCCESS;

1410: IF (G_IS_DEBUG_STATEMENT_ON = true) THEN
1411: OKL_DEBUG_PUB.LOG_DEBUG(FND_LOG.LEVEL_STATEMENT, G_MODULE,l_proc_name);
1412: END IF;
1413:
1414: x_return_status := OKC_API.G_RET_STS_SUCCESS;
1415:
1416: get_contract_rule_group(
1417: p_api_version => 1.0,
1418: p_init_msg_list => OKL_API.G_FALSE,

Line 1430: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN

1426: x_rgpv_tbl => x_rgpv_tbl,
1427: x_rg_count => x_rg_count
1428: );
1429:
1430: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1431: RAISE check_header_failed;
1432: END IF;
1433:
1434: RETURN;

Line 1446: x_return_status := OKC_API.G_RET_STS_ERROR;

1442: SQLCODE,
1443: 'OKL_SQLERRM',
1444: SQLERRM || ': '||G_PKG_NAME||'.'||l_proc_name
1445: );
1446: x_return_status := OKC_API.G_RET_STS_ERROR;
1447: END check_header_rule;
1448:
1449: ------------------------------------------------------------------------------
1450: -- PROCEDURE get_total_capital_amount

Line 1502: x_return_status := OKC_API.G_RET_STS_SUCCESS;

1498: END IF;
1499: IF (G_IS_DEBUG_STATEMENT_ON = true) THEN
1500: OKL_DEBUG_PUB.LOG_DEBUG(FND_LOG.LEVEL_STATEMENT, G_MODULE,l_proc_name);
1501: END IF;
1502: x_return_status := OKC_API.G_RET_STS_SUCCESS;
1503:
1504: OPEN fin_cap_csr(p_chr_id);
1505: FETCH fin_cap_csr INTO l_fin_amount;
1506: IF fin_cap_csr%NOTFOUND THEN

Line 1525: x_return_status := OKC_API.G_RET_STS_ERROR;

1521: IF fin_cap_csr%ISOPEN THEN
1522: CLOSE fin_cap_csr;
1523: END IF;
1524:
1525: x_return_status := OKC_API.G_RET_STS_ERROR;
1526:
1527: WHEN OTHERS THEN
1528: okl_api.set_message(
1529: G_APP_NAME,

Line 1536: x_return_status := OKC_API.G_RET_STS_ERROR;

1532: SQLCODE,
1533: 'OKL_SQLERRM',
1534: SQLERRM || ': '||G_PKG_NAME||'.'||l_proc_name
1535: );
1536: x_return_status := OKC_API.G_RET_STS_ERROR;
1537: END get_total_capital_amount;
1538:
1539:
1540: -- Bug# 7661717 - Added - Start

Line 1641: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN

1637: x_msg_data => x_msg_data,
1638: x_rulv_tbl => x_slh_rulv_tbl,
1639: x_rule_count => x_slh_rule_count
1640: );
1641: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1642: RAISE rule_failed;
1643: END IF;
1644:
1645: IF (x_slh_rule_count = 0) THEN

Line 1675: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN

1671: p_slh_id => x_slh_rulv_tbl(i).id,
1672: x_rulv_tbl => x_sll_rulv_tbl,
1673: x_rule_count => x_sll_rule_count
1674: );
1675: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1676: RAISE rule_failed;
1677: END IF;
1678:
1679: IF (x_sll_rule_count = 0) THEN

Line 1742: p_init_msg_list => OKC_API.G_FALSE,

1738: l_rgpv_rec.dnz_chr_id := p_chr_id;
1739:
1740: OKL_RULE_PUB.create_rule_group(
1741: p_api_version => 1.0,
1742: p_init_msg_list => OKC_API.G_FALSE,
1743: x_return_status => x_return_status,
1744: x_msg_count => x_msg_count,
1745: x_msg_data => x_msg_data,
1746: p_rgpv_rec => l_rgpv_rec,

Line 1749: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN

1745: x_msg_data => x_msg_data,
1746: p_rgpv_rec => l_rgpv_rec,
1747: x_rgpv_rec => x_new_rgpv_rec
1748: );
1749: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1750: x_return_status := OKC_API.G_RET_STS_ERROR;
1751: raise rule_failed;
1752: END IF;
1753: ELSE

Line 1750: x_return_status := OKC_API.G_RET_STS_ERROR;

1746: p_rgpv_rec => l_rgpv_rec,
1747: x_rgpv_rec => x_new_rgpv_rec
1748: );
1749: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1750: x_return_status := OKC_API.G_RET_STS_ERROR;
1751: raise rule_failed;
1752: END IF;
1753: ELSE
1754: x_new_rgpv_rec.id := l_rgp_id;

Line 1767: p_init_msg_list => OKC_API.G_FALSE,

1763: l_slh_rulv_rec := x_slh_rulv_tbl(i);
1764: l_slh_rulv_rec.rgp_id := l_kle_rgp_cache_tbl(k);
1765: OKL_RULE_PUB.create_rule(
1766: p_api_version => 1.0,
1767: p_init_msg_list => OKC_API.G_FALSE,
1768: x_return_status => x_return_status,
1769: x_msg_count => x_msg_count,
1770: x_msg_data => x_msg_data,
1771: p_rulv_rec => l_slh_rulv_rec,

Line 1774: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN

1770: x_msg_data => x_msg_data,
1771: p_rulv_rec => l_slh_rulv_rec,
1772: x_rulv_rec => x_new_slh_rulv_rec
1773: );
1774: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1775: x_return_status := OKC_API.G_RET_STS_ERROR;
1776: raise rule_failed;
1777: END IF;
1778:

Line 1775: x_return_status := OKC_API.G_RET_STS_ERROR;

1771: p_rulv_rec => l_slh_rulv_rec,
1772: x_rulv_rec => x_new_slh_rulv_rec
1773: );
1774: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1775: x_return_status := OKC_API.G_RET_STS_ERROR;
1776: raise rule_failed;
1777: END IF;
1778:
1779: -- set the SLH cache

Line 1835: p_init_msg_list => OKC_API.G_FALSE,

1831: -- Create all SLLs using the table of records of SLLs formed
1832: ---------------------------------------
1833: OKL_RULE_PUB.create_rule(
1834: p_api_version => 1.0,
1835: p_init_msg_list => OKC_API.G_FALSE,
1836: x_return_status => x_return_status,
1837: x_msg_count => x_msg_count,
1838: x_msg_data => x_msg_data,
1839: p_rulv_tbl => l_sll_rulv_tbl,

Line 1842: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN

1838: x_msg_data => x_msg_data,
1839: p_rulv_tbl => l_sll_rulv_tbl,
1840: x_rulv_tbl => x_sll_rulv_new_tbl
1841: );
1842: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1843: x_return_status := OKC_API.G_RET_STS_ERROR;
1844: raise rule_failed;
1845: END IF;
1846: END LOOP; -- end of SLL loop

Line 1843: x_return_status := OKC_API.G_RET_STS_ERROR;

1839: p_rulv_tbl => l_sll_rulv_tbl,
1840: x_rulv_tbl => x_sll_rulv_new_tbl
1841: );
1842: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1843: x_return_status := OKC_API.G_RET_STS_ERROR;
1844: raise rule_failed;
1845: END IF;
1846: END LOOP; -- end of SLL loop
1847: END LOOP; -- end of SLH loop

Line 1941: x_return_status := OKC_API.G_RET_STS_SUCCESS;

1937: IF (G_DEBUG_ENABLED = 'Y') THEN
1938: G_IS_DEBUG_STATEMENT_ON := OKL_DEBUG_PUB.CHECK_LOG_ON(G_MODULE, FND_LOG.LEVEL_STATEMENT);
1939: END IF;
1940:
1941: x_return_status := OKC_API.G_RET_STS_SUCCESS;
1942: IF (G_IS_DEBUG_STATEMENT_ON = true) THEN
1943: OKL_DEBUG_PUB.LOG_DEBUG(FND_LOG.LEVEL_STATEMENT, G_MODULE,l_proc_name);
1944: END IF;
1945: -- call START_ACTIVITY to create savepoint, check compatibility

Line 1947: x_return_status := OKC_API.START_ACTIVITY(

1943: OKL_DEBUG_PUB.LOG_DEBUG(FND_LOG.LEVEL_STATEMENT, G_MODULE,l_proc_name);
1944: END IF;
1945: -- call START_ACTIVITY to create savepoint, check compatibility
1946: -- and initialize message list
1947: x_return_status := OKC_API.START_ACTIVITY(
1948: p_api_name => l_api_name,
1949: p_pkg_name => G_PKG_NAME,
1950: p_init_msg_list => p_init_msg_list,
1951: l_api_version => l_api_version,

Line 1957: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then

1953: p_api_type => G_API_TYPE,
1954: x_return_status => x_return_status);
1955:
1956: -- check if activity started successfully
1957: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
1958: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1959: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
1960: raise OKC_API.G_EXCEPTION_ERROR;
1961: END IF;

Line 1958: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1954: x_return_status => x_return_status);
1955:
1956: -- check if activity started successfully
1957: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
1958: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1959: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
1960: raise OKC_API.G_EXCEPTION_ERROR;
1961: END IF;
1962:

Line 1959: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then

1955:
1956: -- check if activity started successfully
1957: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
1958: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1959: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
1960: raise OKC_API.G_EXCEPTION_ERROR;
1961: END IF;
1962:
1963: --++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

Line 1960: raise OKC_API.G_EXCEPTION_ERROR;

1956: -- check if activity started successfully
1957: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
1958: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1959: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
1960: raise OKC_API.G_EXCEPTION_ERROR;
1961: END IF;
1962:
1963: --++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
1964: -- Check for Line Rule, if present don't proceed with Payment Application

Line 1973: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN

1969: p_chr_id => p_chr_id,
1970: p_stream_id => p_stream_id,
1971: x_rule_present => l_rule_present
1972: );
1973: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1974: RAISE OKC_API.G_EXCEPTION_ERROR;
1975: END IF;
1976:
1977: IF (l_rule_present = 'Y') THEN -- Rule already present at Line level

Line 1974: RAISE OKC_API.G_EXCEPTION_ERROR;

1970: p_stream_id => p_stream_id,
1971: x_rule_present => l_rule_present
1972: );
1973: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1974: RAISE OKC_API.G_EXCEPTION_ERROR;
1975: END IF;
1976:
1977: IF (l_rule_present = 'Y') THEN -- Rule already present at Line level
1978: okl_api.set_message(

Line 1982: RAISE OKC_API.G_EXCEPTION_ERROR;

1978: okl_api.set_message(
1979: G_APP_NAME,
1980: G_RULE_PRESENT_ERROR
1981: );
1982: RAISE OKC_API.G_EXCEPTION_ERROR;
1983: END IF;
1984:
1985: check_header_rule(
1986: x_return_status => x_return_status,

Line 1995: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN

1991: x_rgpv_tbl => l_rgpv_tbl,
1992: x_rg_count => l_rg_count
1993: );
1994:
1995: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1996: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1997: END IF;
1998:
1999: IF (l_rg_count = 0) THEN -- No Rule Groups

Line 1996: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1992: x_rg_count => l_rg_count
1993: );
1994:
1995: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1996: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1997: END IF;
1998:
1999: IF (l_rg_count = 0) THEN -- No Rule Groups
2000: okl_api.set_message(

Line 2004: RAISE OKC_API.G_EXCEPTION_ERROR;

2000: okl_api.set_message(
2001: G_APP_NAME,
2002: G_NO_HEADER_PAYMENT
2003: );
2004: RAISE OKC_API.G_EXCEPTION_ERROR;
2005: END IF;
2006:
2007: get_total_capital_amount(
2008: x_return_status => x_return_status,

Line 2015: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN

2011: p_chr_id => p_chr_id,
2012: x_tot_capital_amount => l_tot_capital_amount
2013: );
2014:
2015: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2016: okl_api.set_message(
2017: G_APP_NAME,
2018: G_CAPITAL_AMT_ERROR
2019: );

Line 2020: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2016: okl_api.set_message(
2017: G_APP_NAME,
2018: G_CAPITAL_AMT_ERROR
2019: );
2020: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2021: END IF;
2022:
2023: get_currency_precision(
2024: x_return_status => x_return_status,

Line 2028: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN

2024: x_return_status => x_return_status,
2025: p_chr_id => p_chr_id,
2026: x_precision => l_precision
2027: );
2028: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2029: RAISE OKC_API.G_EXCEPTION_ERROR;
2030: END IF;
2031:
2032: IF (G_IS_DEBUG_STATEMENT_ON = true) THEN

Line 2029: RAISE OKC_API.G_EXCEPTION_ERROR;

2025: p_chr_id => p_chr_id,
2026: x_precision => l_precision
2027: );
2028: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2029: RAISE OKC_API.G_EXCEPTION_ERROR;
2030: END IF;
2031:
2032: IF (G_IS_DEBUG_STATEMENT_ON = true) THEN
2033: OKL_DEBUG_PUB.LOG_DEBUG(FND_LOG.LEVEL_STATEMENT, G_MODULE,'CAP :'||l_tot_capital_amount);

Line 2057: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN

2053: x_slh_count => x_slh_count,
2054: x_sll_rulv_tbl_out => x_sll_rulv_tbl_out,
2055: x_sll_count => x_sll_count
2056: );
2057: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2058: RAISE OKC_API.G_EXCEPTION_ERROR;
2059: END IF;
2060:
2061: END LOOP;

Line 2058: RAISE OKC_API.G_EXCEPTION_ERROR;

2054: x_sll_rulv_tbl_out => x_sll_rulv_tbl_out,
2055: x_sll_count => x_sll_count
2056: );
2057: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2058: RAISE OKC_API.G_EXCEPTION_ERROR;
2059: END IF;
2060:
2061: END LOOP;
2062: */ -- Bug 7661717 : Start

Line 2089: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN

2085: x_return_status => x_return_status,
2086: x_msg_count => x_msg_count,
2087: x_msg_data => x_msg_data
2088: );
2089: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2090: RAISE OKC_API.G_EXCEPTION_ERROR;
2091: END IF;
2092: -- Bug# 7661717 - Added - End
2093:

Line 2090: RAISE OKC_API.G_EXCEPTION_ERROR;

2086: x_msg_count => x_msg_count,
2087: x_msg_data => x_msg_data
2088: );
2089: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2090: RAISE OKC_API.G_EXCEPTION_ERROR;
2091: END IF;
2092: -- Bug# 7661717 - Added - End
2093:
2094: FOR i IN 1..x_slh_count

Line 2110: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN

2106: x_msg_data => x_msg_data,
2107: p_rulv_tbl => l_slh_rulv_del_tbl
2108: );
2109:
2110: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2111: RAISE OKC_API.G_EXCEPTION_ERROR;
2112: END IF;
2113:
2114: FOR i IN 1..x_sll_count

Line 2111: RAISE OKC_API.G_EXCEPTION_ERROR;

2107: p_rulv_tbl => l_slh_rulv_del_tbl
2108: );
2109:
2110: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2111: RAISE OKC_API.G_EXCEPTION_ERROR;
2112: END IF;
2113:
2114: FOR i IN 1..x_sll_count
2115: LOOP

Line 2130: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN

2126: x_msg_data => x_msg_data,
2127: p_rulv_tbl => l_sll_rulv_del_tbl
2128: );
2129:
2130: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2131: RAISE OKC_API.G_EXCEPTION_ERROR;
2132: END IF;
2133:
2134:

Line 2131: RAISE OKC_API.G_EXCEPTION_ERROR;

2127: p_rulv_tbl => l_sll_rulv_del_tbl
2128: );
2129:
2130: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2131: RAISE OKC_API.G_EXCEPTION_ERROR;
2132: END IF;
2133:
2134:
2135: --

Line 2155: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN

2151: x_msg_count => x_msg_count,
2152: x_msg_data => x_msg_data,
2153: p_rgpv_rec => l_rgpv_del_rec
2154: );
2155: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2156: RAISE OKC_API.G_EXCEPTION_ERROR;
2157: END IF;
2158: END IF;
2159: END LOOP;

Line 2156: RAISE OKC_API.G_EXCEPTION_ERROR;

2152: x_msg_data => x_msg_data,
2153: p_rgpv_rec => l_rgpv_del_rec
2154: );
2155: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2156: RAISE OKC_API.G_EXCEPTION_ERROR;
2157: END IF;
2158: END IF;
2159: END LOOP;
2160:

Line 2167: when OKC_API.G_EXCEPTION_ERROR then

2163: x_msg_data => x_msg_data);
2164:
2165:
2166: EXCEPTION
2167: when OKC_API.G_EXCEPTION_ERROR then
2168: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
2169: p_api_name => l_api_name,
2170: p_pkg_name => G_PKG_NAME,
2171: p_exc_name => 'OKC_API.G_RET_STS_ERROR',

Line 2168: x_return_status := OKC_API.HANDLE_EXCEPTIONS(

2164:
2165:
2166: EXCEPTION
2167: when OKC_API.G_EXCEPTION_ERROR then
2168: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
2169: p_api_name => l_api_name,
2170: p_pkg_name => G_PKG_NAME,
2171: p_exc_name => 'OKC_API.G_RET_STS_ERROR',
2172: x_msg_count => x_msg_count,

Line 2171: p_exc_name => 'OKC_API.G_RET_STS_ERROR',

2167: when OKC_API.G_EXCEPTION_ERROR then
2168: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
2169: p_api_name => l_api_name,
2170: p_pkg_name => G_PKG_NAME,
2171: p_exc_name => 'OKC_API.G_RET_STS_ERROR',
2172: x_msg_count => x_msg_count,
2173: x_msg_data => x_msg_data,
2174: p_api_type => G_API_TYPE);
2175:

Line 2176: when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then

2172: x_msg_count => x_msg_count,
2173: x_msg_data => x_msg_data,
2174: p_api_type => G_API_TYPE);
2175:
2176: when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
2177: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
2178: p_api_name => l_api_name,
2179: p_pkg_name => G_PKG_NAME,
2180: p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 2177: x_return_status := OKC_API.HANDLE_EXCEPTIONS(

2173: x_msg_data => x_msg_data,
2174: p_api_type => G_API_TYPE);
2175:
2176: when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
2177: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
2178: p_api_name => l_api_name,
2179: p_pkg_name => G_PKG_NAME,
2180: p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
2181: x_msg_count => x_msg_count,

Line 2180: p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',

2176: when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
2177: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
2178: p_api_name => l_api_name,
2179: p_pkg_name => G_PKG_NAME,
2180: p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
2181: x_msg_count => x_msg_count,
2182: x_msg_data => x_msg_data,
2183: p_api_type => G_API_TYPE);
2184:

Line 2186: x_return_status := OKC_API.HANDLE_EXCEPTIONS(

2182: x_msg_data => x_msg_data,
2183: p_api_type => G_API_TYPE);
2184:
2185: when OTHERS then
2186: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
2187: p_api_name => l_api_name,
2188: p_pkg_name => G_PKG_NAME,
2189: p_exc_name => 'OTHERS',
2190: x_msg_count => x_msg_count,

Line 2310: x_return_status := OKC_API.G_RET_STS_SUCCESS;

2306: IF (G_DEBUG_ENABLED = 'Y') THEN
2307: G_IS_DEBUG_STATEMENT_ON := OKL_DEBUG_PUB.CHECK_LOG_ON(G_MODULE, FND_LOG.LEVEL_STATEMENT);
2308: END IF;
2309:
2310: x_return_status := OKC_API.G_RET_STS_SUCCESS;
2311: IF (G_IS_DEBUG_STATEMENT_ON = true) THEN
2312: OKL_DEBUG_PUB.LOG_DEBUG(FND_LOG.LEVEL_STATEMENT, G_MODULE,l_proc_name);
2313: END IF;
2314: -- call START_ACTIVITY to create savepoint, check compatibility

Line 2316: x_return_status := OKC_API.START_ACTIVITY(

2312: OKL_DEBUG_PUB.LOG_DEBUG(FND_LOG.LEVEL_STATEMENT, G_MODULE,l_proc_name);
2313: END IF;
2314: -- call START_ACTIVITY to create savepoint, check compatibility
2315: -- and initialize message list
2316: x_return_status := OKC_API.START_ACTIVITY(
2317: p_api_name => l_api_name,
2318: p_pkg_name => G_PKG_NAME,
2319: p_init_msg_list => p_init_msg_list,
2320: l_api_version => l_api_version,

Line 2326: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then

2322: p_api_type => G_API_TYPE,
2323: x_return_status => x_return_status);
2324:
2325: -- check if activity started successfully
2326: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
2327: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2328: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
2329: raise OKC_API.G_EXCEPTION_ERROR;
2330: END IF;

Line 2327: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2323: x_return_status => x_return_status);
2324:
2325: -- check if activity started successfully
2326: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
2327: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2328: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
2329: raise OKC_API.G_EXCEPTION_ERROR;
2330: END IF;
2331:

Line 2328: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then

2324:
2325: -- check if activity started successfully
2326: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
2327: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2328: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
2329: raise OKC_API.G_EXCEPTION_ERROR;
2330: END IF;
2331:
2332: --++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

Line 2329: raise OKC_API.G_EXCEPTION_ERROR;

2325: -- check if activity started successfully
2326: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
2327: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2328: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
2329: raise OKC_API.G_EXCEPTION_ERROR;
2330: END IF;
2331:
2332: --++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
2333: -- Check for Line Rule, if present don't proceed with Payment Application

Line 2342: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN

2338: p_chr_id => p_chr_id,
2339: p_stream_id => p_stream_id,
2340: x_rule_present => l_rule_present
2341: );
2342: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2343: RAISE OKC_API.G_EXCEPTION_ERROR;
2344: END IF;
2345:
2346: IF (l_rule_present = 'Y') THEN -- Rule already present at Line level

Line 2343: RAISE OKC_API.G_EXCEPTION_ERROR;

2339: p_stream_id => p_stream_id,
2340: x_rule_present => l_rule_present
2341: );
2342: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2343: RAISE OKC_API.G_EXCEPTION_ERROR;
2344: END IF;
2345:
2346: IF (l_rule_present = 'Y') THEN -- Rule already present at Line level
2347: okl_api.set_message(

Line 2351: RAISE OKC_API.G_EXCEPTION_ERROR;

2347: okl_api.set_message(
2348: G_APP_NAME,
2349: G_RULE_PRESENT_ERROR
2350: );
2351: RAISE OKC_API.G_EXCEPTION_ERROR;
2352: END IF;
2353:
2354: check_header_rule(
2355: x_return_status => x_return_status,

Line 2364: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN

2360: x_rgpv_tbl => l_rgpv_tbl,
2361: x_rg_count => l_rg_count
2362: );
2363:
2364: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2365: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2366: END IF;
2367:
2368: IF (l_rg_count = 0) THEN -- No Rule Groups

Line 2365: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2361: x_rg_count => l_rg_count
2362: );
2363:
2364: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2365: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2366: END IF;
2367:
2368: IF (l_rg_count = 0) THEN -- No Rule Groups
2369: okl_api.set_message(

Line 2373: RAISE OKC_API.G_EXCEPTION_ERROR;

2369: okl_api.set_message(
2370: G_APP_NAME,
2371: G_NO_HEADER_PAYMENT
2372: );
2373: RAISE OKC_API.G_EXCEPTION_ERROR;
2374: END IF;
2375:
2376: l_tot_capital_amount := 0;
2377: FOR line_cap_rec IN line_cap_csr (p_chr_id)

Line 2387: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN

2383: x_return_status => x_return_status,
2384: p_chr_id => p_chr_id,
2385: x_precision => l_precision
2386: );
2387: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2388: RAISE OKC_API.G_EXCEPTION_ERROR;
2389: END IF;
2390:
2391: IF (G_IS_DEBUG_STATEMENT_ON = true) THEN

Line 2388: RAISE OKC_API.G_EXCEPTION_ERROR;

2384: p_chr_id => p_chr_id,
2385: x_precision => l_precision
2386: );
2387: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2388: RAISE OKC_API.G_EXCEPTION_ERROR;
2389: END IF;
2390:
2391: IF (G_IS_DEBUG_STATEMENT_ON = true) THEN
2392: OKL_DEBUG_PUB.LOG_DEBUG(FND_LOG.LEVEL_STATEMENT, G_MODULE,'CAP :'||l_tot_capital_amount);

Line 2417: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN

2413: x_slh_count => x_slh_count,
2414: x_sll_rulv_tbl_out => x_sll_rulv_tbl_out,
2415: x_sll_count => x_sll_count
2416: );
2417: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2418: RAISE OKC_API.G_EXCEPTION_ERROR;
2419: END IF;
2420:
2421: END LOOP;

Line 2418: RAISE OKC_API.G_EXCEPTION_ERROR;

2414: x_sll_rulv_tbl_out => x_sll_rulv_tbl_out,
2415: x_sll_count => x_sll_count
2416: );
2417: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2418: RAISE OKC_API.G_EXCEPTION_ERROR;
2419: END IF;
2420:
2421: END LOOP;
2422:

Line 2428: RAISE OKC_API.G_EXCEPTION_ERROR;

2424: okl_api.set_message(
2425: G_APP_NAME,
2426: 'OKL_NO_PROP_TAX_AST'
2427: );
2428: RAISE OKC_API.G_EXCEPTION_ERROR;
2429: END IF;
2430:
2431: FOR i IN 1..x_slh_count
2432: LOOP

Line 2447: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN

2443: x_msg_data => x_msg_data,
2444: p_rulv_tbl => l_slh_rulv_del_tbl
2445: );
2446:
2447: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2448: RAISE OKC_API.G_EXCEPTION_ERROR;
2449: END IF;
2450:
2451: FOR i IN 1..x_sll_count

Line 2448: RAISE OKC_API.G_EXCEPTION_ERROR;

2444: p_rulv_tbl => l_slh_rulv_del_tbl
2445: );
2446:
2447: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2448: RAISE OKC_API.G_EXCEPTION_ERROR;
2449: END IF;
2450:
2451: FOR i IN 1..x_sll_count
2452: LOOP

Line 2467: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN

2463: x_msg_data => x_msg_data,
2464: p_rulv_tbl => l_sll_rulv_del_tbl
2465: );
2466:
2467: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2468: RAISE OKC_API.G_EXCEPTION_ERROR;
2469: END IF;
2470:
2471: --

Line 2468: RAISE OKC_API.G_EXCEPTION_ERROR;

2464: p_rulv_tbl => l_sll_rulv_del_tbl
2465: );
2466:
2467: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2468: RAISE OKC_API.G_EXCEPTION_ERROR;
2469: END IF;
2470:
2471: --
2472: -- Delete Header Payment Rule

Line 2491: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN

2487: x_msg_count => x_msg_count,
2488: x_msg_data => x_msg_data,
2489: p_rgpv_rec => l_rgpv_del_rec
2490: );
2491: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2492: RAISE OKC_API.G_EXCEPTION_ERROR;
2493: END IF;
2494: END IF;
2495: END LOOP;

Line 2492: RAISE OKC_API.G_EXCEPTION_ERROR;

2488: x_msg_data => x_msg_data,
2489: p_rgpv_rec => l_rgpv_del_rec
2490: );
2491: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2492: RAISE OKC_API.G_EXCEPTION_ERROR;
2493: END IF;
2494: END IF;
2495: END LOOP;
2496:

Line 2503: when OKC_API.G_EXCEPTION_ERROR then

2499: x_msg_data => x_msg_data);
2500:
2501:
2502: EXCEPTION
2503: when OKC_API.G_EXCEPTION_ERROR then
2504: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
2505: p_api_name => l_api_name,
2506: p_pkg_name => G_PKG_NAME,
2507: p_exc_name => 'OKC_API.G_RET_STS_ERROR',

Line 2504: x_return_status := OKC_API.HANDLE_EXCEPTIONS(

2500:
2501:
2502: EXCEPTION
2503: when OKC_API.G_EXCEPTION_ERROR then
2504: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
2505: p_api_name => l_api_name,
2506: p_pkg_name => G_PKG_NAME,
2507: p_exc_name => 'OKC_API.G_RET_STS_ERROR',
2508: x_msg_count => x_msg_count,

Line 2507: p_exc_name => 'OKC_API.G_RET_STS_ERROR',

2503: when OKC_API.G_EXCEPTION_ERROR then
2504: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
2505: p_api_name => l_api_name,
2506: p_pkg_name => G_PKG_NAME,
2507: p_exc_name => 'OKC_API.G_RET_STS_ERROR',
2508: x_msg_count => x_msg_count,
2509: x_msg_data => x_msg_data,
2510: p_api_type => G_API_TYPE);
2511:

Line 2512: when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then

2508: x_msg_count => x_msg_count,
2509: x_msg_data => x_msg_data,
2510: p_api_type => G_API_TYPE);
2511:
2512: when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
2513: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
2514: p_api_name => l_api_name,
2515: p_pkg_name => G_PKG_NAME,
2516: p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 2513: x_return_status := OKC_API.HANDLE_EXCEPTIONS(

2509: x_msg_data => x_msg_data,
2510: p_api_type => G_API_TYPE);
2511:
2512: when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
2513: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
2514: p_api_name => l_api_name,
2515: p_pkg_name => G_PKG_NAME,
2516: p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
2517: x_msg_count => x_msg_count,

Line 2516: p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',

2512: when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
2513: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
2514: p_api_name => l_api_name,
2515: p_pkg_name => G_PKG_NAME,
2516: p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
2517: x_msg_count => x_msg_count,
2518: x_msg_data => x_msg_data,
2519: p_api_type => G_API_TYPE);
2520:

Line 2522: x_return_status := OKC_API.HANDLE_EXCEPTIONS(

2518: x_msg_data => x_msg_data,
2519: p_api_type => G_API_TYPE);
2520:
2521: when OTHERS then
2522: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
2523: p_api_name => l_api_name,
2524: p_pkg_name => G_PKG_NAME,
2525: p_exc_name => 'OTHERS',
2526: x_msg_count => x_msg_count,

Line 2630: x_return_status := OKC_API.G_RET_STS_SUCCESS;

2626: IF (G_DEBUG_ENABLED = 'Y') THEN
2627: G_IS_DEBUG_STATEMENT_ON := OKL_DEBUG_PUB.CHECK_LOG_ON(G_MODULE, FND_LOG.LEVEL_STATEMENT);
2628: END IF;
2629:
2630: x_return_status := OKC_API.G_RET_STS_SUCCESS;
2631: IF (G_IS_DEBUG_STATEMENT_ON = true) THEN
2632: OKL_DEBUG_PUB.LOG_DEBUG(FND_LOG.LEVEL_STATEMENT, G_MODULE,l_proc_name);
2633: END IF;
2634: -- call START_ACTIVITY to create savepoint, check compatibility

Line 2636: x_return_status := OKC_API.START_ACTIVITY(

2632: OKL_DEBUG_PUB.LOG_DEBUG(FND_LOG.LEVEL_STATEMENT, G_MODULE,l_proc_name);
2633: END IF;
2634: -- call START_ACTIVITY to create savepoint, check compatibility
2635: -- and initialize message list
2636: x_return_status := OKC_API.START_ACTIVITY(
2637: p_api_name => l_api_name,
2638: p_pkg_name => G_PKG_NAME,
2639: p_init_msg_list => p_init_msg_list,
2640: l_api_version => l_api_version,

Line 2646: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then

2642: p_api_type => G_API_TYPE,
2643: x_return_status => x_return_status);
2644:
2645: -- check if activity started successfully
2646: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
2647: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2648: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
2649: raise OKC_API.G_EXCEPTION_ERROR;
2650: END IF;

Line 2647: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2643: x_return_status => x_return_status);
2644:
2645: -- check if activity started successfully
2646: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
2647: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2648: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
2649: raise OKC_API.G_EXCEPTION_ERROR;
2650: END IF;
2651:

Line 2648: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then

2644:
2645: -- check if activity started successfully
2646: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
2647: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2648: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
2649: raise OKC_API.G_EXCEPTION_ERROR;
2650: END IF;
2651:
2652: --++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

Line 2649: raise OKC_API.G_EXCEPTION_ERROR;

2645: -- check if activity started successfully
2646: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
2647: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2648: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
2649: raise OKC_API.G_EXCEPTION_ERROR;
2650: END IF;
2651:
2652: --++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
2653: -- Check if payments already exists for fee-sublines for the given rollover

Line 2664: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN

2660: p_cle_id => p_kle_id,
2661: p_stream_id => p_stream_id,
2662: x_rule_present => l_rule_present
2663: );
2664: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2665: RAISE OKC_API.G_EXCEPTION_ERROR;
2666: END IF;
2667: IF (l_rule_present IS NOT NULL AND l_rule_present = 'Y') THEN -- Rule already present at Line level
2668: okl_api.set_message(

Line 2665: RAISE OKC_API.G_EXCEPTION_ERROR;

2661: p_stream_id => p_stream_id,
2662: x_rule_present => l_rule_present
2663: );
2664: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2665: RAISE OKC_API.G_EXCEPTION_ERROR;
2666: END IF;
2667: IF (l_rule_present IS NOT NULL AND l_rule_present = 'Y') THEN -- Rule already present at Line level
2668: okl_api.set_message(
2669: G_APP_NAME,

Line 2672: RAISE OKC_API.G_EXCEPTION_ERROR;

2668: okl_api.set_message(
2669: G_APP_NAME,
2670: G_RULE_PRESENT_ERROR
2671: );
2672: RAISE OKC_API.G_EXCEPTION_ERROR;
2673: END IF;
2674:
2675: get_ro_fee_topln_rg(
2676: p_api_version => 1.0,

Line 2687: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN

2683: x_msg_count => x_msg_count,
2684: x_msg_data => x_msg_data,
2685: x_rgpv_tbl => l_rgpv_tbl,
2686: x_rg_count => l_rg_count);
2687: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2688: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2689: END IF;
2690:
2691:

Line 2688: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2684: x_msg_data => x_msg_data,
2685: x_rgpv_tbl => l_rgpv_tbl,
2686: x_rg_count => l_rg_count);
2687: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2688: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2689: END IF;
2690:
2691:
2692: IF (l_rg_count = 0) THEN -- No Rule Groups

Line 2697: RAISE OKC_API.G_EXCEPTION_ERROR;

2693: okl_api.set_message(
2694: G_APP_NAME,
2695: G_NO_HEADER_PAYMENT
2696: );
2697: RAISE OKC_API.G_EXCEPTION_ERROR;
2698: END IF;
2699:
2700: l_tot_fee_amount := 0;
2701: OPEN fee_amount_csr(p_kle_id => p_kle_id);

Line 2711: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN

2707: x_return_status => x_return_status,
2708: p_chr_id => p_chr_id,
2709: x_precision => l_precision
2710: );
2711: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2712: RAISE OKC_API.G_EXCEPTION_ERROR;
2713: END IF;
2714:
2715: IF (G_IS_DEBUG_STATEMENT_ON = true) THEN

Line 2712: RAISE OKC_API.G_EXCEPTION_ERROR;

2708: p_chr_id => p_chr_id,
2709: x_precision => l_precision
2710: );
2711: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2712: RAISE OKC_API.G_EXCEPTION_ERROR;
2713: END IF;
2714:
2715: IF (G_IS_DEBUG_STATEMENT_ON = true) THEN
2716: OKL_DEBUG_PUB.LOG_DEBUG(FND_LOG.LEVEL_STATEMENT, G_MODULE,'CAP :'||l_tot_fee_amount);

Line 2748: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN

2744: x_slh_count => x_slh_count,
2745: x_sll_rulv_tbl_out => x_sll_rulv_tbl_out,
2746: x_sll_count => x_sll_count
2747: );
2748: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2749: RAISE OKC_API.G_EXCEPTION_ERROR;
2750: END IF;
2751: END LOOP;
2752: CLOSE ro_fee_subline_csr;

Line 2749: RAISE OKC_API.G_EXCEPTION_ERROR;

2745: x_sll_rulv_tbl_out => x_sll_rulv_tbl_out,
2746: x_sll_count => x_sll_count
2747: );
2748: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2749: RAISE OKC_API.G_EXCEPTION_ERROR;
2750: END IF;
2751: END LOOP;
2752: CLOSE ro_fee_subline_csr;
2753:

Line 2762: RAISE OKC_API.G_EXCEPTION_ERROR;

2758: p_msg_name => 'OKL_RO_NO_SUB_LNS',
2759: p_token1 => 'FEE_LINE',
2760: p_token1_value => l_fee_name
2761: );
2762: RAISE OKC_API.G_EXCEPTION_ERROR;
2763: END IF;
2764:
2765: FOR i IN 1..x_slh_count
2766: LOOP

Line 2781: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN

2777: x_msg_data => x_msg_data,
2778: p_rulv_tbl => l_slh_rulv_del_tbl
2779: );
2780:
2781: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2782: RAISE OKC_API.G_EXCEPTION_ERROR;
2783: END IF;
2784:
2785: FOR i IN 1..x_sll_count

Line 2782: RAISE OKC_API.G_EXCEPTION_ERROR;

2778: p_rulv_tbl => l_slh_rulv_del_tbl
2779: );
2780:
2781: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2782: RAISE OKC_API.G_EXCEPTION_ERROR;
2783: END IF;
2784:
2785: FOR i IN 1..x_sll_count
2786: LOOP

Line 2801: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN

2797: x_msg_data => x_msg_data,
2798: p_rulv_tbl => l_sll_rulv_del_tbl
2799: );
2800:
2801: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2802: RAISE OKC_API.G_EXCEPTION_ERROR;
2803: END IF;
2804:
2805:

Line 2802: RAISE OKC_API.G_EXCEPTION_ERROR;

2798: p_rulv_tbl => l_sll_rulv_del_tbl
2799: );
2800:
2801: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2802: RAISE OKC_API.G_EXCEPTION_ERROR;
2803: END IF;
2804:
2805:
2806: --

Line 2826: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN

2822: x_msg_count => x_msg_count,
2823: x_msg_data => x_msg_data,
2824: p_rgpv_rec => l_rgpv_del_rec
2825: );
2826: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2827: RAISE OKC_API.G_EXCEPTION_ERROR;
2828: END IF;
2829: END IF;
2830: END LOOP;

Line 2827: RAISE OKC_API.G_EXCEPTION_ERROR;

2823: x_msg_data => x_msg_data,
2824: p_rgpv_rec => l_rgpv_del_rec
2825: );
2826: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2827: RAISE OKC_API.G_EXCEPTION_ERROR;
2828: END IF;
2829: END IF;
2830: END LOOP;
2831:

Line 2838: when OKC_API.G_EXCEPTION_ERROR then

2834: x_msg_data => x_msg_data);
2835:
2836:
2837: EXCEPTION
2838: when OKC_API.G_EXCEPTION_ERROR then
2839: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
2840: p_api_name => l_api_name,
2841: p_pkg_name => G_PKG_NAME,
2842: p_exc_name => 'OKC_API.G_RET_STS_ERROR',

Line 2839: x_return_status := OKC_API.HANDLE_EXCEPTIONS(

2835:
2836:
2837: EXCEPTION
2838: when OKC_API.G_EXCEPTION_ERROR then
2839: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
2840: p_api_name => l_api_name,
2841: p_pkg_name => G_PKG_NAME,
2842: p_exc_name => 'OKC_API.G_RET_STS_ERROR',
2843: x_msg_count => x_msg_count,

Line 2842: p_exc_name => 'OKC_API.G_RET_STS_ERROR',

2838: when OKC_API.G_EXCEPTION_ERROR then
2839: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
2840: p_api_name => l_api_name,
2841: p_pkg_name => G_PKG_NAME,
2842: p_exc_name => 'OKC_API.G_RET_STS_ERROR',
2843: x_msg_count => x_msg_count,
2844: x_msg_data => x_msg_data,
2845: p_api_type => G_API_TYPE);
2846:

Line 2847: when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then

2843: x_msg_count => x_msg_count,
2844: x_msg_data => x_msg_data,
2845: p_api_type => G_API_TYPE);
2846:
2847: when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
2848: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
2849: p_api_name => l_api_name,
2850: p_pkg_name => G_PKG_NAME,
2851: p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 2848: x_return_status := OKC_API.HANDLE_EXCEPTIONS(

2844: x_msg_data => x_msg_data,
2845: p_api_type => G_API_TYPE);
2846:
2847: when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
2848: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
2849: p_api_name => l_api_name,
2850: p_pkg_name => G_PKG_NAME,
2851: p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
2852: x_msg_count => x_msg_count,

Line 2851: p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',

2847: when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
2848: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
2849: p_api_name => l_api_name,
2850: p_pkg_name => G_PKG_NAME,
2851: p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
2852: x_msg_count => x_msg_count,
2853: x_msg_data => x_msg_data,
2854: p_api_type => G_API_TYPE);
2855:

Line 2857: x_return_status := OKC_API.HANDLE_EXCEPTIONS(

2853: x_msg_data => x_msg_data,
2854: p_api_type => G_API_TYPE);
2855:
2856: when OTHERS then
2857: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
2858: p_api_name => l_api_name,
2859: p_pkg_name => G_PKG_NAME,
2860: p_exc_name => 'OTHERS',
2861: x_msg_count => x_msg_count,

Line 2965: x_return_status := OKC_API.G_RET_STS_SUCCESS;

2961: IF (G_DEBUG_ENABLED = 'Y') THEN
2962: G_IS_DEBUG_STATEMENT_ON := OKL_DEBUG_PUB.CHECK_LOG_ON(G_MODULE, FND_LOG.LEVEL_STATEMENT);
2963: END IF;
2964:
2965: x_return_status := OKC_API.G_RET_STS_SUCCESS;
2966: IF (G_IS_DEBUG_STATEMENT_ON = true) THEN
2967: OKL_DEBUG_PUB.LOG_DEBUG(FND_LOG.LEVEL_STATEMENT, G_MODULE,l_proc_name);
2968: END IF;
2969: -- call START_ACTIVITY to create savepoint, check compatibility

Line 2971: x_return_status := OKC_API.START_ACTIVITY(

2967: OKL_DEBUG_PUB.LOG_DEBUG(FND_LOG.LEVEL_STATEMENT, G_MODULE,l_proc_name);
2968: END IF;
2969: -- call START_ACTIVITY to create savepoint, check compatibility
2970: -- and initialize message list
2971: x_return_status := OKC_API.START_ACTIVITY(
2972: p_api_name => l_api_name,
2973: p_pkg_name => G_PKG_NAME,
2974: p_init_msg_list => p_init_msg_list,
2975: l_api_version => l_api_version,

Line 2981: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then

2977: p_api_type => G_API_TYPE,
2978: x_return_status => x_return_status);
2979:
2980: -- check if activity started successfully
2981: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
2982: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2983: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
2984: raise OKC_API.G_EXCEPTION_ERROR;
2985: END IF;

Line 2982: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2978: x_return_status => x_return_status);
2979:
2980: -- check if activity started successfully
2981: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
2982: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2983: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
2984: raise OKC_API.G_EXCEPTION_ERROR;
2985: END IF;
2986:

Line 2983: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then

2979:
2980: -- check if activity started successfully
2981: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
2982: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2983: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
2984: raise OKC_API.G_EXCEPTION_ERROR;
2985: END IF;
2986:
2987: --++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

Line 2984: raise OKC_API.G_EXCEPTION_ERROR;

2980: -- check if activity started successfully
2981: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
2982: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2983: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
2984: raise OKC_API.G_EXCEPTION_ERROR;
2985: END IF;
2986:
2987: --++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
2988: -- Check if payments already exists for fee-sublines for the given

Line 2999: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN

2995: p_cle_id => p_kle_id,
2996: p_stream_id => p_stream_id,
2997: x_rule_present => l_rule_present
2998: );
2999: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
3000: RAISE OKC_API.G_EXCEPTION_ERROR;
3001: END IF;
3002: IF (l_rule_present IS NOT NULL AND l_rule_present = 'Y') THEN -- Rule already present at Line level
3003: okl_api.set_message(

Line 3000: RAISE OKC_API.G_EXCEPTION_ERROR;

2996: p_stream_id => p_stream_id,
2997: x_rule_present => l_rule_present
2998: );
2999: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
3000: RAISE OKC_API.G_EXCEPTION_ERROR;
3001: END IF;
3002: IF (l_rule_present IS NOT NULL AND l_rule_present = 'Y') THEN -- Rule already present at Line level
3003: okl_api.set_message(
3004: G_APP_NAME,

Line 3007: RAISE OKC_API.G_EXCEPTION_ERROR;

3003: okl_api.set_message(
3004: G_APP_NAME,
3005: G_RULE_PRESENT_ERROR
3006: );
3007: RAISE OKC_API.G_EXCEPTION_ERROR;
3008: END IF;
3009:
3010: get_ro_fee_topln_rg(
3011: p_api_version => 1.0,

Line 3022: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN

3018: x_msg_count => x_msg_count,
3019: x_msg_data => x_msg_data,
3020: x_rgpv_tbl => l_rgpv_tbl,
3021: x_rg_count => l_rg_count);
3022: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
3023: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3024: END IF;
3025:
3026:

Line 3023: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

3019: x_msg_data => x_msg_data,
3020: x_rgpv_tbl => l_rgpv_tbl,
3021: x_rg_count => l_rg_count);
3022: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
3023: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3024: END IF;
3025:
3026:
3027: IF (l_rg_count = 0) THEN -- No Rule Groups

Line 3032: RAISE OKC_API.G_EXCEPTION_ERROR;

3028: okl_api.set_message(
3029: G_APP_NAME,
3030: G_NO_HEADER_PAYMENT
3031: );
3032: RAISE OKC_API.G_EXCEPTION_ERROR;
3033: END IF;
3034:
3035: l_tot_fee_amount := 0;
3036: OPEN fee_amount_csr(p_kle_id => p_kle_id);

Line 3046: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN

3042: x_return_status => x_return_status,
3043: p_chr_id => p_chr_id,
3044: x_precision => l_precision
3045: );
3046: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
3047: RAISE OKC_API.G_EXCEPTION_ERROR;
3048: END IF;
3049:
3050: IF (G_IS_DEBUG_STATEMENT_ON = true) THEN

Line 3047: RAISE OKC_API.G_EXCEPTION_ERROR;

3043: p_chr_id => p_chr_id,
3044: x_precision => l_precision
3045: );
3046: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
3047: RAISE OKC_API.G_EXCEPTION_ERROR;
3048: END IF;
3049:
3050: IF (G_IS_DEBUG_STATEMENT_ON = true) THEN
3051: OKL_DEBUG_PUB.LOG_DEBUG(FND_LOG.LEVEL_STATEMENT, G_MODULE,'CAP :'||l_tot_fee_amount);

Line 3083: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN

3079: x_slh_count => x_slh_count,
3080: x_sll_rulv_tbl_out => x_sll_rulv_tbl_out,
3081: x_sll_count => x_sll_count
3082: );
3083: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
3084: RAISE OKC_API.G_EXCEPTION_ERROR;
3085: END IF;
3086: END LOOP;
3087: CLOSE ro_fee_subline_csr;

Line 3084: RAISE OKC_API.G_EXCEPTION_ERROR;

3080: x_sll_rulv_tbl_out => x_sll_rulv_tbl_out,
3081: x_sll_count => x_sll_count
3082: );
3083: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
3084: RAISE OKC_API.G_EXCEPTION_ERROR;
3085: END IF;
3086: END LOOP;
3087: CLOSE ro_fee_subline_csr;
3088:

Line 3097: RAISE OKC_API.G_EXCEPTION_ERROR;

3093: p_msg_name => 'OKL_RO_NO_SUB_LNS',
3094: p_token1 => 'FEE_LINE',
3095: p_token1_value => l_fee_name
3096: );
3097: RAISE OKC_API.G_EXCEPTION_ERROR;
3098: END IF;
3099:
3100: FOR i IN 1..x_slh_count
3101: LOOP

Line 3116: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN

3112: x_msg_data => x_msg_data,
3113: p_rulv_tbl => l_slh_rulv_del_tbl
3114: );
3115:
3116: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
3117: RAISE OKC_API.G_EXCEPTION_ERROR;
3118: END IF;
3119:
3120: FOR i IN 1..x_sll_count

Line 3117: RAISE OKC_API.G_EXCEPTION_ERROR;

3113: p_rulv_tbl => l_slh_rulv_del_tbl
3114: );
3115:
3116: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
3117: RAISE OKC_API.G_EXCEPTION_ERROR;
3118: END IF;
3119:
3120: FOR i IN 1..x_sll_count
3121: LOOP

Line 3136: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN

3132: x_msg_data => x_msg_data,
3133: p_rulv_tbl => l_sll_rulv_del_tbl
3134: );
3135:
3136: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
3137: RAISE OKC_API.G_EXCEPTION_ERROR;
3138: END IF;
3139:
3140:

Line 3137: RAISE OKC_API.G_EXCEPTION_ERROR;

3133: p_rulv_tbl => l_sll_rulv_del_tbl
3134: );
3135:
3136: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
3137: RAISE OKC_API.G_EXCEPTION_ERROR;
3138: END IF;
3139:
3140:
3141: --

Line 3161: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN

3157: x_msg_count => x_msg_count,
3158: x_msg_data => x_msg_data,
3159: p_rgpv_rec => l_rgpv_del_rec
3160: );
3161: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
3162: RAISE OKC_API.G_EXCEPTION_ERROR;
3163: END IF;
3164: END IF;
3165: END LOOP;

Line 3162: RAISE OKC_API.G_EXCEPTION_ERROR;

3158: x_msg_data => x_msg_data,
3159: p_rgpv_rec => l_rgpv_del_rec
3160: );
3161: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
3162: RAISE OKC_API.G_EXCEPTION_ERROR;
3163: END IF;
3164: END IF;
3165: END LOOP;
3166:

Line 3173: when OKC_API.G_EXCEPTION_ERROR then

3169: x_msg_data => x_msg_data);
3170:
3171:
3172: EXCEPTION
3173: when OKC_API.G_EXCEPTION_ERROR then
3174: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
3175: p_api_name => l_api_name,
3176: p_pkg_name => G_PKG_NAME,
3177: p_exc_name => 'OKC_API.G_RET_STS_ERROR',

Line 3174: x_return_status := OKC_API.HANDLE_EXCEPTIONS(

3170:
3171:
3172: EXCEPTION
3173: when OKC_API.G_EXCEPTION_ERROR then
3174: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
3175: p_api_name => l_api_name,
3176: p_pkg_name => G_PKG_NAME,
3177: p_exc_name => 'OKC_API.G_RET_STS_ERROR',
3178: x_msg_count => x_msg_count,

Line 3177: p_exc_name => 'OKC_API.G_RET_STS_ERROR',

3173: when OKC_API.G_EXCEPTION_ERROR then
3174: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
3175: p_api_name => l_api_name,
3176: p_pkg_name => G_PKG_NAME,
3177: p_exc_name => 'OKC_API.G_RET_STS_ERROR',
3178: x_msg_count => x_msg_count,
3179: x_msg_data => x_msg_data,
3180: p_api_type => G_API_TYPE);
3181:

Line 3182: when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then

3178: x_msg_count => x_msg_count,
3179: x_msg_data => x_msg_data,
3180: p_api_type => G_API_TYPE);
3181:
3182: when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
3183: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
3184: p_api_name => l_api_name,
3185: p_pkg_name => G_PKG_NAME,
3186: p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 3183: x_return_status := OKC_API.HANDLE_EXCEPTIONS(

3179: x_msg_data => x_msg_data,
3180: p_api_type => G_API_TYPE);
3181:
3182: when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
3183: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
3184: p_api_name => l_api_name,
3185: p_pkg_name => G_PKG_NAME,
3186: p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
3187: x_msg_count => x_msg_count,

Line 3186: p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',

3182: when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
3183: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
3184: p_api_name => l_api_name,
3185: p_pkg_name => G_PKG_NAME,
3186: p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
3187: x_msg_count => x_msg_count,
3188: x_msg_data => x_msg_data,
3189: p_api_type => G_API_TYPE);
3190:

Line 3192: x_return_status := OKC_API.HANDLE_EXCEPTIONS(

3188: x_msg_data => x_msg_data,
3189: p_api_type => G_API_TYPE);
3190:
3191: when OTHERS then
3192: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
3193: p_api_name => l_api_name,
3194: p_pkg_name => G_PKG_NAME,
3195: p_exc_name => 'OTHERS',
3196: x_msg_count => x_msg_count,

Line 3263: x_return_status := OKC_API.G_RET_STS_SUCCESS;

3259: IF (G_DEBUG_ENABLED = 'Y') THEN
3260: G_IS_DEBUG_STATEMENT_ON := OKL_DEBUG_PUB.CHECK_LOG_ON(G_MODULE, FND_LOG.LEVEL_STATEMENT);
3261: END IF;
3262:
3263: x_return_status := OKC_API.G_RET_STS_SUCCESS;
3264: IF (G_IS_DEBUG_STATEMENT_ON = true) THEN
3265: OKL_DEBUG_PUB.LOG_DEBUG(FND_LOG.LEVEL_STATEMENT, G_MODULE,l_proc_name);
3266: END IF;
3267:

Line 3270: x_return_status := OKC_API.START_ACTIVITY(

3266: END IF;
3267:
3268: -- call START_ACTIVITY to create savepoint, check compatibility
3269: -- and initialize message list
3270: x_return_status := OKC_API.START_ACTIVITY(
3271: p_api_name => l_api_name,
3272: p_pkg_name => G_PKG_NAME,
3273: p_init_msg_list => p_init_msg_list,
3274: l_api_version => l_api_version,

Line 3280: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then

3276: p_api_type => G_API_TYPE,
3277: x_return_status => x_return_status);
3278:
3279: -- check if activity started successfully
3280: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
3281: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3282: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
3283: raise OKC_API.G_EXCEPTION_ERROR;
3284: END IF;

Line 3281: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

3277: x_return_status => x_return_status);
3278:
3279: -- check if activity started successfully
3280: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
3281: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3282: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
3283: raise OKC_API.G_EXCEPTION_ERROR;
3284: END IF;
3285:

Line 3282: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then

3278:
3279: -- check if activity started successfully
3280: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
3281: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3282: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
3283: raise OKC_API.G_EXCEPTION_ERROR;
3284: END IF;
3285:
3286: --++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

Line 3283: raise OKC_API.G_EXCEPTION_ERROR;

3279: -- check if activity started successfully
3280: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
3281: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3282: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
3283: raise OKC_API.G_EXCEPTION_ERROR;
3284: END IF;
3285:
3286: --++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
3287:

Line 3300: p_init_msg_list => OKC_API.G_FALSE,

3296:
3297: IF (i > 0) THEN
3298: okl_rule_pub.delete_rule(
3299: p_api_version => 1.0,
3300: p_init_msg_list => OKC_API.G_FALSE,
3301: x_return_status => x_return_status,
3302: x_msg_count => x_msg_count,
3303: x_msg_data => x_msg_data,
3304: p_rulv_tbl => l_rulv_tbl

Line 3306: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then

3302: x_msg_count => x_msg_count,
3303: x_msg_data => x_msg_data,
3304: p_rulv_tbl => l_rulv_tbl
3305: );
3306: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
3307: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3308: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
3309: raise OKC_API.G_EXCEPTION_ERROR;
3310: END IF;

Line 3307: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

3303: x_msg_data => x_msg_data,
3304: p_rulv_tbl => l_rulv_tbl
3305: );
3306: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
3307: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3308: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
3309: raise OKC_API.G_EXCEPTION_ERROR;
3310: END IF;
3311:

Line 3308: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then

3304: p_rulv_tbl => l_rulv_tbl
3305: );
3306: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
3307: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3308: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
3309: raise OKC_API.G_EXCEPTION_ERROR;
3310: END IF;
3311:
3312: END IF;

Line 3309: raise OKC_API.G_EXCEPTION_ERROR;

3305: );
3306: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
3307: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3308: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
3309: raise OKC_API.G_EXCEPTION_ERROR;
3310: END IF;
3311:
3312: END IF;
3313:

Line 3325: p_init_msg_list => OKC_API.G_FALSE,

3321:
3322: l_rulv_rec.id := p_rule_id; -- SLH Rule ID
3323: okl_rule_pub.delete_rule(
3324: p_api_version => 1.0,
3325: p_init_msg_list => OKC_API.G_FALSE,
3326: x_return_status => x_return_status,
3327: x_msg_count => x_msg_count,
3328: x_msg_data => x_msg_data,
3329: p_rulv_rec => l_rulv_rec

Line 3331: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then

3327: x_msg_count => x_msg_count,
3328: x_msg_data => x_msg_data,
3329: p_rulv_rec => l_rulv_rec
3330: );
3331: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
3332: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3333: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
3334: raise OKC_API.G_EXCEPTION_ERROR;
3335: END IF;

Line 3332: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

3328: x_msg_data => x_msg_data,
3329: p_rulv_rec => l_rulv_rec
3330: );
3331: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
3332: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3333: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
3334: raise OKC_API.G_EXCEPTION_ERROR;
3335: END IF;
3336:

Line 3333: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then

3329: p_rulv_rec => l_rulv_rec
3330: );
3331: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
3332: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3333: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
3334: raise OKC_API.G_EXCEPTION_ERROR;
3335: END IF;
3336:
3337: END IF;

Line 3334: raise OKC_API.G_EXCEPTION_ERROR;

3330: );
3331: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
3332: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3333: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
3334: raise OKC_API.G_EXCEPTION_ERROR;
3335: END IF;
3336:
3337: END IF;
3338:

Line 3357: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then

3353: x_msg_data => x_msg_data,
3354: p_rgpv_rec => l_rgpv_rec
3355: );
3356:
3357: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
3358: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3359: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
3360: raise OKC_API.G_EXCEPTION_ERROR;
3361: END IF;

Line 3358: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

3354: p_rgpv_rec => l_rgpv_rec
3355: );
3356:
3357: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
3358: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3359: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
3360: raise OKC_API.G_EXCEPTION_ERROR;
3361: END IF;
3362:

Line 3359: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then

3355: );
3356:
3357: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
3358: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3359: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
3360: raise OKC_API.G_EXCEPTION_ERROR;
3361: END IF;
3362:
3363: END IF;

Line 3360: raise OKC_API.G_EXCEPTION_ERROR;

3356:
3357: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
3358: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3359: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
3360: raise OKC_API.G_EXCEPTION_ERROR;
3361: END IF;
3362:
3363: END IF;
3364:

Line 3373: when OKC_API.G_EXCEPTION_ERROR then

3369: x_msg_data => x_msg_data);
3370:
3371:
3372: EXCEPTION
3373: when OKC_API.G_EXCEPTION_ERROR then
3374: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
3375: p_api_name => l_api_name,
3376: p_pkg_name => G_PKG_NAME,
3377: p_exc_name => 'OKC_API.G_RET_STS_ERROR',

Line 3374: x_return_status := OKC_API.HANDLE_EXCEPTIONS(

3370:
3371:
3372: EXCEPTION
3373: when OKC_API.G_EXCEPTION_ERROR then
3374: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
3375: p_api_name => l_api_name,
3376: p_pkg_name => G_PKG_NAME,
3377: p_exc_name => 'OKC_API.G_RET_STS_ERROR',
3378: x_msg_count => x_msg_count,

Line 3377: p_exc_name => 'OKC_API.G_RET_STS_ERROR',

3373: when OKC_API.G_EXCEPTION_ERROR then
3374: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
3375: p_api_name => l_api_name,
3376: p_pkg_name => G_PKG_NAME,
3377: p_exc_name => 'OKC_API.G_RET_STS_ERROR',
3378: x_msg_count => x_msg_count,
3379: x_msg_data => x_msg_data,
3380: p_api_type => G_API_TYPE);
3381:

Line 3382: when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then

3378: x_msg_count => x_msg_count,
3379: x_msg_data => x_msg_data,
3380: p_api_type => G_API_TYPE);
3381:
3382: when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
3383: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
3384: p_api_name => l_api_name,
3385: p_pkg_name => G_PKG_NAME,
3386: p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 3383: x_return_status := OKC_API.HANDLE_EXCEPTIONS(

3379: x_msg_data => x_msg_data,
3380: p_api_type => G_API_TYPE);
3381:
3382: when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
3383: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
3384: p_api_name => l_api_name,
3385: p_pkg_name => G_PKG_NAME,
3386: p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
3387: x_msg_count => x_msg_count,

Line 3386: p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',

3382: when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
3383: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
3384: p_api_name => l_api_name,
3385: p_pkg_name => G_PKG_NAME,
3386: p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
3387: x_msg_count => x_msg_count,
3388: x_msg_data => x_msg_data,
3389: p_api_type => G_API_TYPE);
3390:

Line 3392: x_return_status := OKC_API.HANDLE_EXCEPTIONS(

3388: x_msg_data => x_msg_data,
3389: p_api_type => G_API_TYPE);
3390:
3391: when OTHERS then
3392: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
3393: p_api_name => l_api_name,
3394: p_pkg_name => G_PKG_NAME,
3395: p_exc_name => 'OTHERS',
3396: x_msg_count => x_msg_count,