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 112: x_return_status := OKC_API.G_RET_STS_SUCCESS;

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

Line 132: x_return_status := OKC_API.G_RET_STS_ERROR;

128: WHEN OTHERS THEN
129: IF lrule_csr%ISOPEN THEN
130: CLOSE lrule_csr;
131: END IF;
132: x_return_status := OKC_API.G_RET_STS_ERROR;
133: okl_api.set_message(
134: G_APP_NAME,
135: G_UNEXPECTED_ERROR,
136: 'OKL_SQLCODE',

Line 199: x_return_status := OKC_API.G_RET_STS_SUCCESS;

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

Line 223: x_return_status := OKC_API.G_RET_STS_ERROR;

219: WHEN OTHERS THEN
220: IF l_ro_sl_rule_csr%ISOPEN THEN
221: CLOSE l_ro_sl_rule_csr;
222: END IF;
223: x_return_status := OKC_API.G_RET_STS_ERROR;
224: okl_api.set_message(
225: G_APP_NAME,
226: G_UNEXPECTED_ERROR,
227: 'OKL_SQLCODE',

Line 277: x_return_status := OKC_API.G_RET_STS_SUCCESS;

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

Line 1078: x_return_status := OKC_API.G_RET_STS_SUCCESS;

1074: l_precision FND_CURRENCIES.PRECISION%TYPE;
1075:
1076: BEGIN
1077:
1078: x_return_status := OKC_API.G_RET_STS_SUCCESS;
1079: OPEN chr_csr(p_chr_id);
1080: FETCH chr_csr INTO l_currency_code;
1081: IF chr_csr%NOTFOUND THEN
1082: okl_api.set_message(

Line 1109: x_return_status := OKC_API.G_RET_STS_ERROR;

1105: RETURN;
1106:
1107: EXCEPTION
1108: WHEN curr_failed THEN
1109: x_return_status := OKC_API.G_RET_STS_ERROR;
1110: END get_currency_precision;
1111:
1112: ------------------------------------------------------------------------------
1113: -- PROCEDURE create_line_rule

Line 1186: x_return_status := OKC_API.G_RET_STS_SUCCESS;

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

Line 1215: p_init_msg_list => OKC_API.G_FALSE,

1211: l_rgpv_rec.dnz_chr_id := p_chr_id;
1212:
1213: OKL_RULE_PUB.create_rule_group(
1214: p_api_version => 1.0,
1215: p_init_msg_list => OKC_API.G_FALSE,
1216: x_return_status => x_return_status,
1217: x_msg_count => x_msg_count,
1218: x_msg_data => x_msg_data,
1219: p_rgpv_rec => l_rgpv_rec,

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

1218: x_msg_data => x_msg_data,
1219: p_rgpv_rec => l_rgpv_rec,
1220: x_rgpv_rec => x_new_rgpv_rec
1221: );
1222: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1223: x_return_status := OKC_API.G_RET_STS_ERROR;
1224: raise rule_failed;
1225: END IF;
1226: ELSE

Line 1223: x_return_status := OKC_API.G_RET_STS_ERROR;

1219: p_rgpv_rec => l_rgpv_rec,
1220: x_rgpv_rec => x_new_rgpv_rec
1221: );
1222: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1223: x_return_status := OKC_API.G_RET_STS_ERROR;
1224: raise rule_failed;
1225: END IF;
1226: ELSE
1227: x_new_rgpv_rec.id := l_rgp_id;

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

1237: x_msg_data => x_msg_data,
1238: x_rulv_tbl => x_slh_rulv_tbl,
1239: x_rule_count => x_slh_rule_count
1240: );
1241: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1242: RAISE rule_failed;
1243: END IF;
1244:
1245: IF (x_slh_rule_count = 0) THEN

Line 1262: p_init_msg_list => OKC_API.G_FALSE,

1258: l_slh_rulv_rec := x_slh_rulv_tbl(i);
1259: l_slh_rulv_rec.rgp_id := x_new_rgpv_rec.id;
1260: OKL_RULE_PUB.create_rule(
1261: p_api_version => 1.0,
1262: p_init_msg_list => OKC_API.G_FALSE,
1263: x_return_status => x_return_status,
1264: x_msg_count => x_msg_count,
1265: x_msg_data => x_msg_data,
1266: p_rulv_rec => l_slh_rulv_rec,

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

1265: x_msg_data => x_msg_data,
1266: p_rulv_rec => l_slh_rulv_rec,
1267: x_rulv_rec => x_new_slh_rulv_rec
1268: );
1269: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1270: x_return_status := OKC_API.G_RET_STS_ERROR;
1271: raise rule_failed;
1272: END IF;
1273:

Line 1270: x_return_status := OKC_API.G_RET_STS_ERROR;

1266: p_rulv_rec => l_slh_rulv_rec,
1267: x_rulv_rec => x_new_slh_rulv_rec
1268: );
1269: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1270: x_return_status := OKC_API.G_RET_STS_ERROR;
1271: raise rule_failed;
1272: END IF;
1273:
1274: --okl_rule_apis_pvt.Get_Contract_Rules(

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

1282: p_slh_id => x_slh_rulv_tbl(i).id,
1283: x_rulv_tbl => x_sll_rulv_tbl,
1284: x_rule_count => x_sll_rule_count
1285: );
1286: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1287: RAISE rule_failed;
1288: END IF;
1289:
1290: IF (x_sll_rule_count = 0) THEN

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

1315: x_msg_data => x_msg_data,
1316: p_fin_line_id => p_cle_id,
1317: x_fee_cap_amt => l_fee_line_capital_amount
1318: );
1319: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1320: x_return_status := OKC_API.G_RET_STS_ERROR;
1321: raise rule_failed;
1322: END IF;
1323: END IF;

Line 1320: x_return_status := OKC_API.G_RET_STS_ERROR;

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

Line 1349: p_init_msg_list => OKC_API.G_FALSE,

1345: l_sll_rulv_rec.object2_id1 := x_new_slh_rulv_rec.id;
1346:
1347: OKL_RULE_PUB.create_rule(
1348: p_api_version => 1.0,
1349: p_init_msg_list => OKC_API.G_FALSE,
1350: x_return_status => x_return_status,
1351: x_msg_count => x_msg_count,
1352: x_msg_data => x_msg_data,
1353: p_rulv_rec => l_sll_rulv_rec,

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

1352: x_msg_data => x_msg_data,
1353: p_rulv_rec => l_sll_rulv_rec,
1354: x_rulv_rec => x_rulv_rec
1355: );
1356: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1357: x_return_status := OKC_API.G_RET_STS_ERROR;
1358: raise rule_failed;
1359: END IF;
1360: END LOOP; -- SLL

Line 1357: x_return_status := OKC_API.G_RET_STS_ERROR;

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

Line 1368: x_return_status := OKC_API.G_RET_STS_ERROR;

1364: RETURN;
1365:
1366: EXCEPTION
1367: WHEN rule_failed THEN
1368: x_return_status := OKC_API.G_RET_STS_ERROR;
1369: WHEN OTHERS THEN
1370: okl_api.set_message(
1371: G_APP_NAME,
1372: G_UNEXPECTED_ERROR,

Line 1378: x_return_status := OKC_API.G_RET_STS_ERROR;

1374: SQLCODE,
1375: 'OKL_SQLERRM',
1376: SQLERRM || ': '||G_PKG_NAME||'.'||l_proc_name
1377: );
1378: x_return_status := OKC_API.G_RET_STS_ERROR;
1379: END create_line_rule;
1380:
1381:
1382: ------------------------------------------------------------------------------

Line 1410: x_return_status := OKC_API.G_RET_STS_SUCCESS;

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

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

1422: x_rgpv_tbl => x_rgpv_tbl,
1423: x_rg_count => x_rg_count
1424: );
1425:
1426: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1427: RAISE check_header_failed;
1428: END IF;
1429:
1430: RETURN;

Line 1442: x_return_status := OKC_API.G_RET_STS_ERROR;

1438: SQLCODE,
1439: 'OKL_SQLERRM',
1440: SQLERRM || ': '||G_PKG_NAME||'.'||l_proc_name
1441: );
1442: x_return_status := OKC_API.G_RET_STS_ERROR;
1443: END check_header_rule;
1444:
1445: ------------------------------------------------------------------------------
1446: -- PROCEDURE get_total_capital_amount

Line 1498: x_return_status := OKC_API.G_RET_STS_SUCCESS;

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

Line 1521: x_return_status := OKC_API.G_RET_STS_ERROR;

1517: IF fin_cap_csr%ISOPEN THEN
1518: CLOSE fin_cap_csr;
1519: END IF;
1520:
1521: x_return_status := OKC_API.G_RET_STS_ERROR;
1522:
1523: WHEN OTHERS THEN
1524: okl_api.set_message(
1525: G_APP_NAME,

Line 1532: x_return_status := OKC_API.G_RET_STS_ERROR;

1528: SQLCODE,
1529: 'OKL_SQLERRM',
1530: SQLERRM || ': '||G_PKG_NAME||'.'||l_proc_name
1531: );
1532: x_return_status := OKC_API.G_RET_STS_ERROR;
1533: END get_total_capital_amount;
1534:
1535:
1536:

Line 1613: x_return_status := OKC_API.G_RET_STS_SUCCESS;

1609: IF (G_DEBUG_ENABLED = 'Y') THEN
1610: G_IS_DEBUG_STATEMENT_ON := OKL_DEBUG_PUB.CHECK_LOG_ON(G_MODULE, FND_LOG.LEVEL_STATEMENT);
1611: END IF;
1612:
1613: x_return_status := OKC_API.G_RET_STS_SUCCESS;
1614: IF (G_IS_DEBUG_STATEMENT_ON = true) THEN
1615: OKL_DEBUG_PUB.LOG_DEBUG(FND_LOG.LEVEL_STATEMENT, G_MODULE,l_proc_name);
1616: END IF;
1617: -- call START_ACTIVITY to create savepoint, check compatibility

Line 1619: x_return_status := OKC_API.START_ACTIVITY(

1615: OKL_DEBUG_PUB.LOG_DEBUG(FND_LOG.LEVEL_STATEMENT, G_MODULE,l_proc_name);
1616: END IF;
1617: -- call START_ACTIVITY to create savepoint, check compatibility
1618: -- and initialize message list
1619: x_return_status := OKC_API.START_ACTIVITY(
1620: p_api_name => l_api_name,
1621: p_pkg_name => G_PKG_NAME,
1622: p_init_msg_list => p_init_msg_list,
1623: l_api_version => l_api_version,

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

1625: p_api_type => G_API_TYPE,
1626: x_return_status => x_return_status);
1627:
1628: -- check if activity started successfully
1629: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
1630: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1631: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
1632: raise OKC_API.G_EXCEPTION_ERROR;
1633: END IF;

Line 1630: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1626: x_return_status => x_return_status);
1627:
1628: -- check if activity started successfully
1629: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
1630: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1631: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
1632: raise OKC_API.G_EXCEPTION_ERROR;
1633: END IF;
1634:

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

1627:
1628: -- check if activity started successfully
1629: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
1630: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1631: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
1632: raise OKC_API.G_EXCEPTION_ERROR;
1633: END IF;
1634:
1635: --++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

Line 1632: raise OKC_API.G_EXCEPTION_ERROR;

1628: -- check if activity started successfully
1629: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
1630: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1631: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
1632: raise OKC_API.G_EXCEPTION_ERROR;
1633: END IF;
1634:
1635: --++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
1636: -- Check for Line Rule, if present don't proceed with Payment Application

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

1641: p_chr_id => p_chr_id,
1642: p_stream_id => p_stream_id,
1643: x_rule_present => l_rule_present
1644: );
1645: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1646: RAISE OKC_API.G_EXCEPTION_ERROR;
1647: END IF;
1648:
1649: IF (l_rule_present = 'Y') THEN -- Rule already present at Line level

Line 1646: RAISE OKC_API.G_EXCEPTION_ERROR;

1642: p_stream_id => p_stream_id,
1643: x_rule_present => l_rule_present
1644: );
1645: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1646: RAISE OKC_API.G_EXCEPTION_ERROR;
1647: END IF;
1648:
1649: IF (l_rule_present = 'Y') THEN -- Rule already present at Line level
1650: okl_api.set_message(

Line 1654: RAISE OKC_API.G_EXCEPTION_ERROR;

1650: okl_api.set_message(
1651: G_APP_NAME,
1652: G_RULE_PRESENT_ERROR
1653: );
1654: RAISE OKC_API.G_EXCEPTION_ERROR;
1655: END IF;
1656:
1657: check_header_rule(
1658: x_return_status => x_return_status,

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

1663: x_rgpv_tbl => l_rgpv_tbl,
1664: x_rg_count => l_rg_count
1665: );
1666:
1667: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1668: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1669: END IF;
1670:
1671: IF (l_rg_count = 0) THEN -- No Rule Groups

Line 1668: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1664: x_rg_count => l_rg_count
1665: );
1666:
1667: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1668: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1669: END IF;
1670:
1671: IF (l_rg_count = 0) THEN -- No Rule Groups
1672: okl_api.set_message(

Line 1676: RAISE OKC_API.G_EXCEPTION_ERROR;

1672: okl_api.set_message(
1673: G_APP_NAME,
1674: G_NO_HEADER_PAYMENT
1675: );
1676: RAISE OKC_API.G_EXCEPTION_ERROR;
1677: END IF;
1678:
1679: get_total_capital_amount(
1680: x_return_status => x_return_status,

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

1683: p_chr_id => p_chr_id,
1684: x_tot_capital_amount => l_tot_capital_amount
1685: );
1686:
1687: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1688: okl_api.set_message(
1689: G_APP_NAME,
1690: G_CAPITAL_AMT_ERROR
1691: );

Line 1692: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1688: okl_api.set_message(
1689: G_APP_NAME,
1690: G_CAPITAL_AMT_ERROR
1691: );
1692: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1693: END IF;
1694:
1695: get_currency_precision(
1696: x_return_status => x_return_status,

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

1696: x_return_status => x_return_status,
1697: p_chr_id => p_chr_id,
1698: x_precision => l_precision
1699: );
1700: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1701: RAISE OKC_API.G_EXCEPTION_ERROR;
1702: END IF;
1703:
1704: IF (G_IS_DEBUG_STATEMENT_ON = true) THEN

Line 1701: RAISE OKC_API.G_EXCEPTION_ERROR;

1697: p_chr_id => p_chr_id,
1698: x_precision => l_precision
1699: );
1700: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1701: RAISE OKC_API.G_EXCEPTION_ERROR;
1702: END IF;
1703:
1704: IF (G_IS_DEBUG_STATEMENT_ON = true) THEN
1705: OKL_DEBUG_PUB.LOG_DEBUG(FND_LOG.LEVEL_STATEMENT, G_MODULE,'CAP :'||l_tot_capital_amount);

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

1723: x_slh_count => x_slh_count,
1724: x_sll_rulv_tbl_out => x_sll_rulv_tbl_out,
1725: x_sll_count => x_sll_count
1726: );
1727: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1728: RAISE OKC_API.G_EXCEPTION_ERROR;
1729: END IF;
1730:
1731: END LOOP;

Line 1728: RAISE OKC_API.G_EXCEPTION_ERROR;

1724: x_sll_rulv_tbl_out => x_sll_rulv_tbl_out,
1725: x_sll_count => x_sll_count
1726: );
1727: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1728: RAISE OKC_API.G_EXCEPTION_ERROR;
1729: END IF;
1730:
1731: END LOOP;
1732:

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

1746: x_msg_data => x_msg_data,
1747: p_rulv_tbl => l_slh_rulv_del_tbl
1748: );
1749:
1750: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1751: RAISE OKC_API.G_EXCEPTION_ERROR;
1752: END IF;
1753:
1754: FOR i IN 1..x_sll_count

Line 1751: RAISE OKC_API.G_EXCEPTION_ERROR;

1747: p_rulv_tbl => l_slh_rulv_del_tbl
1748: );
1749:
1750: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1751: RAISE OKC_API.G_EXCEPTION_ERROR;
1752: END IF;
1753:
1754: FOR i IN 1..x_sll_count
1755: LOOP

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

1766: x_msg_data => x_msg_data,
1767: p_rulv_tbl => l_sll_rulv_del_tbl
1768: );
1769:
1770: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1771: RAISE OKC_API.G_EXCEPTION_ERROR;
1772: END IF;
1773:
1774:

Line 1771: RAISE OKC_API.G_EXCEPTION_ERROR;

1767: p_rulv_tbl => l_sll_rulv_del_tbl
1768: );
1769:
1770: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1771: RAISE OKC_API.G_EXCEPTION_ERROR;
1772: END IF;
1773:
1774:
1775: --

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

1791: x_msg_count => x_msg_count,
1792: x_msg_data => x_msg_data,
1793: p_rgpv_rec => l_rgpv_del_rec
1794: );
1795: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1796: RAISE OKC_API.G_EXCEPTION_ERROR;
1797: END IF;
1798: END IF;
1799: END LOOP;

Line 1796: RAISE OKC_API.G_EXCEPTION_ERROR;

1792: x_msg_data => x_msg_data,
1793: p_rgpv_rec => l_rgpv_del_rec
1794: );
1795: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1796: RAISE OKC_API.G_EXCEPTION_ERROR;
1797: END IF;
1798: END IF;
1799: END LOOP;
1800:

Line 1807: when OKC_API.G_EXCEPTION_ERROR then

1803: x_msg_data => x_msg_data);
1804:
1805:
1806: EXCEPTION
1807: when OKC_API.G_EXCEPTION_ERROR then
1808: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
1809: p_api_name => l_api_name,
1810: p_pkg_name => G_PKG_NAME,
1811: p_exc_name => 'OKC_API.G_RET_STS_ERROR',

Line 1808: x_return_status := OKC_API.HANDLE_EXCEPTIONS(

1804:
1805:
1806: EXCEPTION
1807: when OKC_API.G_EXCEPTION_ERROR then
1808: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
1809: p_api_name => l_api_name,
1810: p_pkg_name => G_PKG_NAME,
1811: p_exc_name => 'OKC_API.G_RET_STS_ERROR',
1812: x_msg_count => x_msg_count,

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

1807: when OKC_API.G_EXCEPTION_ERROR then
1808: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
1809: p_api_name => l_api_name,
1810: p_pkg_name => G_PKG_NAME,
1811: p_exc_name => 'OKC_API.G_RET_STS_ERROR',
1812: x_msg_count => x_msg_count,
1813: x_msg_data => x_msg_data,
1814: p_api_type => G_API_TYPE);
1815:

Line 1816: when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then

1812: x_msg_count => x_msg_count,
1813: x_msg_data => x_msg_data,
1814: p_api_type => G_API_TYPE);
1815:
1816: when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
1817: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
1818: p_api_name => l_api_name,
1819: p_pkg_name => G_PKG_NAME,
1820: p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 1817: x_return_status := OKC_API.HANDLE_EXCEPTIONS(

1813: x_msg_data => x_msg_data,
1814: p_api_type => G_API_TYPE);
1815:
1816: when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
1817: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
1818: p_api_name => l_api_name,
1819: p_pkg_name => G_PKG_NAME,
1820: p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
1821: x_msg_count => x_msg_count,

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

1816: when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
1817: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
1818: p_api_name => l_api_name,
1819: p_pkg_name => G_PKG_NAME,
1820: p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
1821: x_msg_count => x_msg_count,
1822: x_msg_data => x_msg_data,
1823: p_api_type => G_API_TYPE);
1824:

Line 1826: x_return_status := OKC_API.HANDLE_EXCEPTIONS(

1822: x_msg_data => x_msg_data,
1823: p_api_type => G_API_TYPE);
1824:
1825: when OTHERS then
1826: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
1827: p_api_name => l_api_name,
1828: p_pkg_name => G_PKG_NAME,
1829: p_exc_name => 'OTHERS',
1830: x_msg_count => x_msg_count,

Line 1950: x_return_status := OKC_API.G_RET_STS_SUCCESS;

1946: IF (G_DEBUG_ENABLED = 'Y') THEN
1947: G_IS_DEBUG_STATEMENT_ON := OKL_DEBUG_PUB.CHECK_LOG_ON(G_MODULE, FND_LOG.LEVEL_STATEMENT);
1948: END IF;
1949:
1950: x_return_status := OKC_API.G_RET_STS_SUCCESS;
1951: IF (G_IS_DEBUG_STATEMENT_ON = true) THEN
1952: OKL_DEBUG_PUB.LOG_DEBUG(FND_LOG.LEVEL_STATEMENT, G_MODULE,l_proc_name);
1953: END IF;
1954: -- call START_ACTIVITY to create savepoint, check compatibility

Line 1956: x_return_status := OKC_API.START_ACTIVITY(

1952: OKL_DEBUG_PUB.LOG_DEBUG(FND_LOG.LEVEL_STATEMENT, G_MODULE,l_proc_name);
1953: END IF;
1954: -- call START_ACTIVITY to create savepoint, check compatibility
1955: -- and initialize message list
1956: x_return_status := OKC_API.START_ACTIVITY(
1957: p_api_name => l_api_name,
1958: p_pkg_name => G_PKG_NAME,
1959: p_init_msg_list => p_init_msg_list,
1960: l_api_version => l_api_version,

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

1962: p_api_type => G_API_TYPE,
1963: x_return_status => x_return_status);
1964:
1965: -- check if activity started successfully
1966: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
1967: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1968: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
1969: raise OKC_API.G_EXCEPTION_ERROR;
1970: END IF;

Line 1967: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1963: x_return_status => x_return_status);
1964:
1965: -- check if activity started successfully
1966: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
1967: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1968: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
1969: raise OKC_API.G_EXCEPTION_ERROR;
1970: END IF;
1971:

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

1964:
1965: -- check if activity started successfully
1966: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
1967: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1968: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
1969: raise OKC_API.G_EXCEPTION_ERROR;
1970: END IF;
1971:
1972: --++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

Line 1969: raise OKC_API.G_EXCEPTION_ERROR;

1965: -- check if activity started successfully
1966: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
1967: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1968: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
1969: raise OKC_API.G_EXCEPTION_ERROR;
1970: END IF;
1971:
1972: --++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
1973: -- Check for Line Rule, if present don't proceed with Payment Application

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

1978: p_chr_id => p_chr_id,
1979: p_stream_id => p_stream_id,
1980: x_rule_present => l_rule_present
1981: );
1982: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1983: RAISE OKC_API.G_EXCEPTION_ERROR;
1984: END IF;
1985:
1986: IF (l_rule_present = 'Y') THEN -- Rule already present at Line level

Line 1983: RAISE OKC_API.G_EXCEPTION_ERROR;

1979: p_stream_id => p_stream_id,
1980: x_rule_present => l_rule_present
1981: );
1982: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1983: RAISE OKC_API.G_EXCEPTION_ERROR;
1984: END IF;
1985:
1986: IF (l_rule_present = 'Y') THEN -- Rule already present at Line level
1987: okl_api.set_message(

Line 1991: RAISE OKC_API.G_EXCEPTION_ERROR;

1987: okl_api.set_message(
1988: G_APP_NAME,
1989: G_RULE_PRESENT_ERROR
1990: );
1991: RAISE OKC_API.G_EXCEPTION_ERROR;
1992: END IF;
1993:
1994: check_header_rule(
1995: x_return_status => x_return_status,

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

2000: x_rgpv_tbl => l_rgpv_tbl,
2001: x_rg_count => l_rg_count
2002: );
2003:
2004: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2005: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2006: END IF;
2007:
2008: IF (l_rg_count = 0) THEN -- No Rule Groups

Line 2005: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2001: x_rg_count => l_rg_count
2002: );
2003:
2004: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2005: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2006: END IF;
2007:
2008: IF (l_rg_count = 0) THEN -- No Rule Groups
2009: okl_api.set_message(

Line 2013: RAISE OKC_API.G_EXCEPTION_ERROR;

2009: okl_api.set_message(
2010: G_APP_NAME,
2011: G_NO_HEADER_PAYMENT
2012: );
2013: RAISE OKC_API.G_EXCEPTION_ERROR;
2014: END IF;
2015:
2016: l_tot_capital_amount := 0;
2017: FOR line_cap_rec IN line_cap_csr (p_chr_id)

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

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

Line 2028: RAISE OKC_API.G_EXCEPTION_ERROR;

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

Line 2068: RAISE OKC_API.G_EXCEPTION_ERROR;

2064: okl_api.set_message(
2065: G_APP_NAME,
2066: 'OKL_NO_PROP_TAX_AST'
2067: );
2068: RAISE OKC_API.G_EXCEPTION_ERROR;
2069: END IF;
2070:
2071: FOR i IN 1..x_slh_count
2072: LOOP

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

2083: x_msg_data => x_msg_data,
2084: p_rulv_tbl => l_slh_rulv_del_tbl
2085: );
2086:
2087: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2088: RAISE OKC_API.G_EXCEPTION_ERROR;
2089: END IF;
2090:
2091: FOR i IN 1..x_sll_count

Line 2088: RAISE OKC_API.G_EXCEPTION_ERROR;

2084: p_rulv_tbl => l_slh_rulv_del_tbl
2085: );
2086:
2087: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2088: RAISE OKC_API.G_EXCEPTION_ERROR;
2089: END IF;
2090:
2091: FOR i IN 1..x_sll_count
2092: LOOP

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

2103: x_msg_data => x_msg_data,
2104: p_rulv_tbl => l_sll_rulv_del_tbl
2105: );
2106:
2107: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2108: RAISE OKC_API.G_EXCEPTION_ERROR;
2109: END IF;
2110:
2111: --

Line 2108: RAISE OKC_API.G_EXCEPTION_ERROR;

2104: p_rulv_tbl => l_sll_rulv_del_tbl
2105: );
2106:
2107: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2108: RAISE OKC_API.G_EXCEPTION_ERROR;
2109: END IF;
2110:
2111: --
2112: -- Delete Header Payment Rule

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

2127: x_msg_count => x_msg_count,
2128: x_msg_data => x_msg_data,
2129: p_rgpv_rec => l_rgpv_del_rec
2130: );
2131: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2132: RAISE OKC_API.G_EXCEPTION_ERROR;
2133: END IF;
2134: END IF;
2135: END LOOP;

Line 2132: RAISE OKC_API.G_EXCEPTION_ERROR;

2128: x_msg_data => x_msg_data,
2129: p_rgpv_rec => l_rgpv_del_rec
2130: );
2131: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2132: RAISE OKC_API.G_EXCEPTION_ERROR;
2133: END IF;
2134: END IF;
2135: END LOOP;
2136:

Line 2143: when OKC_API.G_EXCEPTION_ERROR then

2139: x_msg_data => x_msg_data);
2140:
2141:
2142: EXCEPTION
2143: when OKC_API.G_EXCEPTION_ERROR then
2144: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
2145: p_api_name => l_api_name,
2146: p_pkg_name => G_PKG_NAME,
2147: p_exc_name => 'OKC_API.G_RET_STS_ERROR',

Line 2144: x_return_status := OKC_API.HANDLE_EXCEPTIONS(

2140:
2141:
2142: EXCEPTION
2143: when OKC_API.G_EXCEPTION_ERROR then
2144: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
2145: p_api_name => l_api_name,
2146: p_pkg_name => G_PKG_NAME,
2147: p_exc_name => 'OKC_API.G_RET_STS_ERROR',
2148: x_msg_count => x_msg_count,

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

2143: when OKC_API.G_EXCEPTION_ERROR then
2144: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
2145: p_api_name => l_api_name,
2146: p_pkg_name => G_PKG_NAME,
2147: p_exc_name => 'OKC_API.G_RET_STS_ERROR',
2148: x_msg_count => x_msg_count,
2149: x_msg_data => x_msg_data,
2150: p_api_type => G_API_TYPE);
2151:

Line 2152: when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then

2148: x_msg_count => x_msg_count,
2149: x_msg_data => x_msg_data,
2150: p_api_type => G_API_TYPE);
2151:
2152: when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
2153: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
2154: p_api_name => l_api_name,
2155: p_pkg_name => G_PKG_NAME,
2156: p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 2153: x_return_status := OKC_API.HANDLE_EXCEPTIONS(

2149: x_msg_data => x_msg_data,
2150: p_api_type => G_API_TYPE);
2151:
2152: when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
2153: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
2154: p_api_name => l_api_name,
2155: p_pkg_name => G_PKG_NAME,
2156: p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
2157: x_msg_count => x_msg_count,

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

2152: when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
2153: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
2154: p_api_name => l_api_name,
2155: p_pkg_name => G_PKG_NAME,
2156: p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
2157: x_msg_count => x_msg_count,
2158: x_msg_data => x_msg_data,
2159: p_api_type => G_API_TYPE);
2160:

Line 2162: x_return_status := OKC_API.HANDLE_EXCEPTIONS(

2158: x_msg_data => x_msg_data,
2159: p_api_type => G_API_TYPE);
2160:
2161: when OTHERS then
2162: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
2163: p_api_name => l_api_name,
2164: p_pkg_name => G_PKG_NAME,
2165: p_exc_name => 'OTHERS',
2166: x_msg_count => x_msg_count,

Line 2270: x_return_status := OKC_API.G_RET_STS_SUCCESS;

2266: IF (G_DEBUG_ENABLED = 'Y') THEN
2267: G_IS_DEBUG_STATEMENT_ON := OKL_DEBUG_PUB.CHECK_LOG_ON(G_MODULE, FND_LOG.LEVEL_STATEMENT);
2268: END IF;
2269:
2270: x_return_status := OKC_API.G_RET_STS_SUCCESS;
2271: IF (G_IS_DEBUG_STATEMENT_ON = true) THEN
2272: OKL_DEBUG_PUB.LOG_DEBUG(FND_LOG.LEVEL_STATEMENT, G_MODULE,l_proc_name);
2273: END IF;
2274: -- call START_ACTIVITY to create savepoint, check compatibility

Line 2276: x_return_status := OKC_API.START_ACTIVITY(

2272: OKL_DEBUG_PUB.LOG_DEBUG(FND_LOG.LEVEL_STATEMENT, G_MODULE,l_proc_name);
2273: END IF;
2274: -- call START_ACTIVITY to create savepoint, check compatibility
2275: -- and initialize message list
2276: x_return_status := OKC_API.START_ACTIVITY(
2277: p_api_name => l_api_name,
2278: p_pkg_name => G_PKG_NAME,
2279: p_init_msg_list => p_init_msg_list,
2280: l_api_version => l_api_version,

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

2282: p_api_type => G_API_TYPE,
2283: x_return_status => x_return_status);
2284:
2285: -- check if activity started successfully
2286: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
2287: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2288: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
2289: raise OKC_API.G_EXCEPTION_ERROR;
2290: END IF;

Line 2287: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2283: x_return_status => x_return_status);
2284:
2285: -- check if activity started successfully
2286: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
2287: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2288: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
2289: raise OKC_API.G_EXCEPTION_ERROR;
2290: END IF;
2291:

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

2284:
2285: -- check if activity started successfully
2286: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
2287: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2288: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
2289: raise OKC_API.G_EXCEPTION_ERROR;
2290: END IF;
2291:
2292: --++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

Line 2289: raise OKC_API.G_EXCEPTION_ERROR;

2285: -- check if activity started successfully
2286: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
2287: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2288: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
2289: raise OKC_API.G_EXCEPTION_ERROR;
2290: END IF;
2291:
2292: --++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
2293: -- Check if payments already exists for fee-sublines for the given rollover

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

2300: p_cle_id => p_kle_id,
2301: p_stream_id => p_stream_id,
2302: x_rule_present => l_rule_present
2303: );
2304: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2305: RAISE OKC_API.G_EXCEPTION_ERROR;
2306: END IF;
2307: IF (l_rule_present IS NOT NULL AND l_rule_present = 'Y') THEN -- Rule already present at Line level
2308: okl_api.set_message(

Line 2305: RAISE OKC_API.G_EXCEPTION_ERROR;

2301: p_stream_id => p_stream_id,
2302: x_rule_present => l_rule_present
2303: );
2304: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2305: RAISE OKC_API.G_EXCEPTION_ERROR;
2306: END IF;
2307: IF (l_rule_present IS NOT NULL AND l_rule_present = 'Y') THEN -- Rule already present at Line level
2308: okl_api.set_message(
2309: G_APP_NAME,

Line 2312: RAISE OKC_API.G_EXCEPTION_ERROR;

2308: okl_api.set_message(
2309: G_APP_NAME,
2310: G_RULE_PRESENT_ERROR
2311: );
2312: RAISE OKC_API.G_EXCEPTION_ERROR;
2313: END IF;
2314:
2315: get_ro_fee_topln_rg(
2316: p_api_version => 1.0,

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

2323: x_msg_count => x_msg_count,
2324: x_msg_data => x_msg_data,
2325: x_rgpv_tbl => l_rgpv_tbl,
2326: x_rg_count => l_rg_count);
2327: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2328: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2329: END IF;
2330:
2331:

Line 2328: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2324: x_msg_data => x_msg_data,
2325: x_rgpv_tbl => l_rgpv_tbl,
2326: x_rg_count => l_rg_count);
2327: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2328: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2329: END IF;
2330:
2331:
2332: IF (l_rg_count = 0) THEN -- No Rule Groups

Line 2337: RAISE OKC_API.G_EXCEPTION_ERROR;

2333: okl_api.set_message(
2334: G_APP_NAME,
2335: G_NO_HEADER_PAYMENT
2336: );
2337: RAISE OKC_API.G_EXCEPTION_ERROR;
2338: END IF;
2339:
2340: l_tot_fee_amount := 0;
2341: OPEN fee_amount_csr(p_kle_id => p_kle_id);

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

2347: x_return_status => x_return_status,
2348: p_chr_id => p_chr_id,
2349: x_precision => l_precision
2350: );
2351: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2352: RAISE OKC_API.G_EXCEPTION_ERROR;
2353: END IF;
2354:
2355: IF (G_IS_DEBUG_STATEMENT_ON = true) THEN

Line 2352: RAISE OKC_API.G_EXCEPTION_ERROR;

2348: p_chr_id => p_chr_id,
2349: x_precision => l_precision
2350: );
2351: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2352: RAISE OKC_API.G_EXCEPTION_ERROR;
2353: END IF;
2354:
2355: IF (G_IS_DEBUG_STATEMENT_ON = true) THEN
2356: OKL_DEBUG_PUB.LOG_DEBUG(FND_LOG.LEVEL_STATEMENT, G_MODULE,'CAP :'||l_tot_fee_amount);

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

2384: x_slh_count => x_slh_count,
2385: x_sll_rulv_tbl_out => x_sll_rulv_tbl_out,
2386: x_sll_count => x_sll_count
2387: );
2388: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2389: RAISE OKC_API.G_EXCEPTION_ERROR;
2390: END IF;
2391: END LOOP;
2392: CLOSE ro_fee_subline_csr;

Line 2389: RAISE OKC_API.G_EXCEPTION_ERROR;

2385: x_sll_rulv_tbl_out => x_sll_rulv_tbl_out,
2386: x_sll_count => x_sll_count
2387: );
2388: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2389: RAISE OKC_API.G_EXCEPTION_ERROR;
2390: END IF;
2391: END LOOP;
2392: CLOSE ro_fee_subline_csr;
2393:

Line 2402: RAISE OKC_API.G_EXCEPTION_ERROR;

2398: p_msg_name => 'OKL_RO_NO_SUB_LNS',
2399: p_token1 => 'FEE_LINE',
2400: p_token1_value => l_fee_name
2401: );
2402: RAISE OKC_API.G_EXCEPTION_ERROR;
2403: END IF;
2404:
2405: FOR i IN 1..x_slh_count
2406: LOOP

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

2417: x_msg_data => x_msg_data,
2418: p_rulv_tbl => l_slh_rulv_del_tbl
2419: );
2420:
2421: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2422: RAISE OKC_API.G_EXCEPTION_ERROR;
2423: END IF;
2424:
2425: FOR i IN 1..x_sll_count

Line 2422: RAISE OKC_API.G_EXCEPTION_ERROR;

2418: p_rulv_tbl => l_slh_rulv_del_tbl
2419: );
2420:
2421: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2422: RAISE OKC_API.G_EXCEPTION_ERROR;
2423: END IF;
2424:
2425: FOR i IN 1..x_sll_count
2426: LOOP

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

2437: x_msg_data => x_msg_data,
2438: p_rulv_tbl => l_sll_rulv_del_tbl
2439: );
2440:
2441: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2442: RAISE OKC_API.G_EXCEPTION_ERROR;
2443: END IF;
2444:
2445:

Line 2442: RAISE OKC_API.G_EXCEPTION_ERROR;

2438: p_rulv_tbl => l_sll_rulv_del_tbl
2439: );
2440:
2441: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2442: RAISE OKC_API.G_EXCEPTION_ERROR;
2443: END IF;
2444:
2445:
2446: --

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

2462: x_msg_count => x_msg_count,
2463: x_msg_data => x_msg_data,
2464: p_rgpv_rec => l_rgpv_del_rec
2465: );
2466: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2467: RAISE OKC_API.G_EXCEPTION_ERROR;
2468: END IF;
2469: END IF;
2470: END LOOP;

Line 2467: RAISE OKC_API.G_EXCEPTION_ERROR;

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

Line 2478: when OKC_API.G_EXCEPTION_ERROR then

2474: x_msg_data => x_msg_data);
2475:
2476:
2477: EXCEPTION
2478: when OKC_API.G_EXCEPTION_ERROR then
2479: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
2480: p_api_name => l_api_name,
2481: p_pkg_name => G_PKG_NAME,
2482: p_exc_name => 'OKC_API.G_RET_STS_ERROR',

Line 2479: x_return_status := OKC_API.HANDLE_EXCEPTIONS(

2475:
2476:
2477: EXCEPTION
2478: when OKC_API.G_EXCEPTION_ERROR then
2479: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
2480: p_api_name => l_api_name,
2481: p_pkg_name => G_PKG_NAME,
2482: p_exc_name => 'OKC_API.G_RET_STS_ERROR',
2483: x_msg_count => x_msg_count,

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

2478: when OKC_API.G_EXCEPTION_ERROR then
2479: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
2480: p_api_name => l_api_name,
2481: p_pkg_name => G_PKG_NAME,
2482: p_exc_name => 'OKC_API.G_RET_STS_ERROR',
2483: x_msg_count => x_msg_count,
2484: x_msg_data => x_msg_data,
2485: p_api_type => G_API_TYPE);
2486:

Line 2487: when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then

2483: x_msg_count => x_msg_count,
2484: x_msg_data => x_msg_data,
2485: p_api_type => G_API_TYPE);
2486:
2487: when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
2488: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
2489: p_api_name => l_api_name,
2490: p_pkg_name => G_PKG_NAME,
2491: p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 2488: x_return_status := OKC_API.HANDLE_EXCEPTIONS(

2484: x_msg_data => x_msg_data,
2485: p_api_type => G_API_TYPE);
2486:
2487: when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
2488: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
2489: p_api_name => l_api_name,
2490: p_pkg_name => G_PKG_NAME,
2491: p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
2492: x_msg_count => x_msg_count,

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

2487: when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
2488: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
2489: p_api_name => l_api_name,
2490: p_pkg_name => G_PKG_NAME,
2491: p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
2492: x_msg_count => x_msg_count,
2493: x_msg_data => x_msg_data,
2494: p_api_type => G_API_TYPE);
2495:

Line 2497: x_return_status := OKC_API.HANDLE_EXCEPTIONS(

2493: x_msg_data => x_msg_data,
2494: p_api_type => G_API_TYPE);
2495:
2496: when OTHERS then
2497: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
2498: p_api_name => l_api_name,
2499: p_pkg_name => G_PKG_NAME,
2500: p_exc_name => 'OTHERS',
2501: x_msg_count => x_msg_count,

Line 2605: x_return_status := OKC_API.G_RET_STS_SUCCESS;

2601: IF (G_DEBUG_ENABLED = 'Y') THEN
2602: G_IS_DEBUG_STATEMENT_ON := OKL_DEBUG_PUB.CHECK_LOG_ON(G_MODULE, FND_LOG.LEVEL_STATEMENT);
2603: END IF;
2604:
2605: x_return_status := OKC_API.G_RET_STS_SUCCESS;
2606: IF (G_IS_DEBUG_STATEMENT_ON = true) THEN
2607: OKL_DEBUG_PUB.LOG_DEBUG(FND_LOG.LEVEL_STATEMENT, G_MODULE,l_proc_name);
2608: END IF;
2609: -- call START_ACTIVITY to create savepoint, check compatibility

Line 2611: x_return_status := OKC_API.START_ACTIVITY(

2607: OKL_DEBUG_PUB.LOG_DEBUG(FND_LOG.LEVEL_STATEMENT, G_MODULE,l_proc_name);
2608: END IF;
2609: -- call START_ACTIVITY to create savepoint, check compatibility
2610: -- and initialize message list
2611: x_return_status := OKC_API.START_ACTIVITY(
2612: p_api_name => l_api_name,
2613: p_pkg_name => G_PKG_NAME,
2614: p_init_msg_list => p_init_msg_list,
2615: l_api_version => l_api_version,

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

2617: p_api_type => G_API_TYPE,
2618: x_return_status => x_return_status);
2619:
2620: -- check if activity started successfully
2621: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
2622: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2623: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
2624: raise OKC_API.G_EXCEPTION_ERROR;
2625: END IF;

Line 2622: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2618: x_return_status => x_return_status);
2619:
2620: -- check if activity started successfully
2621: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
2622: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2623: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
2624: raise OKC_API.G_EXCEPTION_ERROR;
2625: END IF;
2626:

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

2619:
2620: -- check if activity started successfully
2621: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
2622: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2623: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
2624: raise OKC_API.G_EXCEPTION_ERROR;
2625: END IF;
2626:
2627: --++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

Line 2624: raise OKC_API.G_EXCEPTION_ERROR;

2620: -- check if activity started successfully
2621: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
2622: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2623: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
2624: raise OKC_API.G_EXCEPTION_ERROR;
2625: END IF;
2626:
2627: --++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
2628: -- Check if payments already exists for fee-sublines for the given

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

2635: p_cle_id => p_kle_id,
2636: p_stream_id => p_stream_id,
2637: x_rule_present => l_rule_present
2638: );
2639: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2640: RAISE OKC_API.G_EXCEPTION_ERROR;
2641: END IF;
2642: IF (l_rule_present IS NOT NULL AND l_rule_present = 'Y') THEN -- Rule already present at Line level
2643: okl_api.set_message(

Line 2640: RAISE OKC_API.G_EXCEPTION_ERROR;

2636: p_stream_id => p_stream_id,
2637: x_rule_present => l_rule_present
2638: );
2639: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2640: RAISE OKC_API.G_EXCEPTION_ERROR;
2641: END IF;
2642: IF (l_rule_present IS NOT NULL AND l_rule_present = 'Y') THEN -- Rule already present at Line level
2643: okl_api.set_message(
2644: G_APP_NAME,

Line 2647: RAISE OKC_API.G_EXCEPTION_ERROR;

2643: okl_api.set_message(
2644: G_APP_NAME,
2645: G_RULE_PRESENT_ERROR
2646: );
2647: RAISE OKC_API.G_EXCEPTION_ERROR;
2648: END IF;
2649:
2650: get_ro_fee_topln_rg(
2651: p_api_version => 1.0,

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

2658: x_msg_count => x_msg_count,
2659: x_msg_data => x_msg_data,
2660: x_rgpv_tbl => l_rgpv_tbl,
2661: x_rg_count => l_rg_count);
2662: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2663: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2664: END IF;
2665:
2666:

Line 2663: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2659: x_msg_data => x_msg_data,
2660: x_rgpv_tbl => l_rgpv_tbl,
2661: x_rg_count => l_rg_count);
2662: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2663: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2664: END IF;
2665:
2666:
2667: IF (l_rg_count = 0) THEN -- No Rule Groups

Line 2672: RAISE OKC_API.G_EXCEPTION_ERROR;

2668: okl_api.set_message(
2669: G_APP_NAME,
2670: G_NO_HEADER_PAYMENT
2671: );
2672: RAISE OKC_API.G_EXCEPTION_ERROR;
2673: END IF;
2674:
2675: l_tot_fee_amount := 0;
2676: OPEN fee_amount_csr(p_kle_id => p_kle_id);

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

2682: x_return_status => x_return_status,
2683: p_chr_id => p_chr_id,
2684: x_precision => l_precision
2685: );
2686: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2687: RAISE OKC_API.G_EXCEPTION_ERROR;
2688: END IF;
2689:
2690: IF (G_IS_DEBUG_STATEMENT_ON = true) THEN

Line 2687: RAISE OKC_API.G_EXCEPTION_ERROR;

2683: p_chr_id => p_chr_id,
2684: x_precision => l_precision
2685: );
2686: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2687: RAISE OKC_API.G_EXCEPTION_ERROR;
2688: END IF;
2689:
2690: IF (G_IS_DEBUG_STATEMENT_ON = true) THEN
2691: OKL_DEBUG_PUB.LOG_DEBUG(FND_LOG.LEVEL_STATEMENT, G_MODULE,'CAP :'||l_tot_fee_amount);

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

2719: x_slh_count => x_slh_count,
2720: x_sll_rulv_tbl_out => x_sll_rulv_tbl_out,
2721: x_sll_count => x_sll_count
2722: );
2723: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2724: RAISE OKC_API.G_EXCEPTION_ERROR;
2725: END IF;
2726: END LOOP;
2727: CLOSE ro_fee_subline_csr;

Line 2724: RAISE OKC_API.G_EXCEPTION_ERROR;

2720: x_sll_rulv_tbl_out => x_sll_rulv_tbl_out,
2721: x_sll_count => x_sll_count
2722: );
2723: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2724: RAISE OKC_API.G_EXCEPTION_ERROR;
2725: END IF;
2726: END LOOP;
2727: CLOSE ro_fee_subline_csr;
2728:

Line 2737: RAISE OKC_API.G_EXCEPTION_ERROR;

2733: p_msg_name => 'OKL_RO_NO_SUB_LNS',
2734: p_token1 => 'FEE_LINE',
2735: p_token1_value => l_fee_name
2736: );
2737: RAISE OKC_API.G_EXCEPTION_ERROR;
2738: END IF;
2739:
2740: FOR i IN 1..x_slh_count
2741: LOOP

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

2752: x_msg_data => x_msg_data,
2753: p_rulv_tbl => l_slh_rulv_del_tbl
2754: );
2755:
2756: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2757: RAISE OKC_API.G_EXCEPTION_ERROR;
2758: END IF;
2759:
2760: FOR i IN 1..x_sll_count

Line 2757: RAISE OKC_API.G_EXCEPTION_ERROR;

2753: p_rulv_tbl => l_slh_rulv_del_tbl
2754: );
2755:
2756: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2757: RAISE OKC_API.G_EXCEPTION_ERROR;
2758: END IF;
2759:
2760: FOR i IN 1..x_sll_count
2761: LOOP

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

2772: x_msg_data => x_msg_data,
2773: p_rulv_tbl => l_sll_rulv_del_tbl
2774: );
2775:
2776: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2777: RAISE OKC_API.G_EXCEPTION_ERROR;
2778: END IF;
2779:
2780:

Line 2777: RAISE OKC_API.G_EXCEPTION_ERROR;

2773: p_rulv_tbl => l_sll_rulv_del_tbl
2774: );
2775:
2776: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2777: RAISE OKC_API.G_EXCEPTION_ERROR;
2778: END IF;
2779:
2780:
2781: --

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

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

Line 2802: RAISE OKC_API.G_EXCEPTION_ERROR;

2798: x_msg_data => x_msg_data,
2799: p_rgpv_rec => l_rgpv_del_rec
2800: );
2801: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2802: RAISE OKC_API.G_EXCEPTION_ERROR;
2803: END IF;
2804: END IF;
2805: END LOOP;
2806:

Line 2813: when OKC_API.G_EXCEPTION_ERROR then

2809: x_msg_data => x_msg_data);
2810:
2811:
2812: EXCEPTION
2813: when OKC_API.G_EXCEPTION_ERROR then
2814: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
2815: p_api_name => l_api_name,
2816: p_pkg_name => G_PKG_NAME,
2817: p_exc_name => 'OKC_API.G_RET_STS_ERROR',

Line 2814: x_return_status := OKC_API.HANDLE_EXCEPTIONS(

2810:
2811:
2812: EXCEPTION
2813: when OKC_API.G_EXCEPTION_ERROR then
2814: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
2815: p_api_name => l_api_name,
2816: p_pkg_name => G_PKG_NAME,
2817: p_exc_name => 'OKC_API.G_RET_STS_ERROR',
2818: x_msg_count => x_msg_count,

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

2813: when OKC_API.G_EXCEPTION_ERROR then
2814: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
2815: p_api_name => l_api_name,
2816: p_pkg_name => G_PKG_NAME,
2817: p_exc_name => 'OKC_API.G_RET_STS_ERROR',
2818: x_msg_count => x_msg_count,
2819: x_msg_data => x_msg_data,
2820: p_api_type => G_API_TYPE);
2821:

Line 2822: when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then

2818: x_msg_count => x_msg_count,
2819: x_msg_data => x_msg_data,
2820: p_api_type => G_API_TYPE);
2821:
2822: when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
2823: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
2824: p_api_name => l_api_name,
2825: p_pkg_name => G_PKG_NAME,
2826: p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 2823: x_return_status := OKC_API.HANDLE_EXCEPTIONS(

2819: x_msg_data => x_msg_data,
2820: p_api_type => G_API_TYPE);
2821:
2822: when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
2823: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
2824: p_api_name => l_api_name,
2825: p_pkg_name => G_PKG_NAME,
2826: p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
2827: x_msg_count => x_msg_count,

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

2822: when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
2823: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
2824: p_api_name => l_api_name,
2825: p_pkg_name => G_PKG_NAME,
2826: p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
2827: x_msg_count => x_msg_count,
2828: x_msg_data => x_msg_data,
2829: p_api_type => G_API_TYPE);
2830:

Line 2832: x_return_status := OKC_API.HANDLE_EXCEPTIONS(

2828: x_msg_data => x_msg_data,
2829: p_api_type => G_API_TYPE);
2830:
2831: when OTHERS then
2832: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
2833: p_api_name => l_api_name,
2834: p_pkg_name => G_PKG_NAME,
2835: p_exc_name => 'OTHERS',
2836: x_msg_count => x_msg_count,

Line 2903: x_return_status := OKC_API.G_RET_STS_SUCCESS;

2899: IF (G_DEBUG_ENABLED = 'Y') THEN
2900: G_IS_DEBUG_STATEMENT_ON := OKL_DEBUG_PUB.CHECK_LOG_ON(G_MODULE, FND_LOG.LEVEL_STATEMENT);
2901: END IF;
2902:
2903: x_return_status := OKC_API.G_RET_STS_SUCCESS;
2904: IF (G_IS_DEBUG_STATEMENT_ON = true) THEN
2905: OKL_DEBUG_PUB.LOG_DEBUG(FND_LOG.LEVEL_STATEMENT, G_MODULE,l_proc_name);
2906: END IF;
2907:

Line 2910: x_return_status := OKC_API.START_ACTIVITY(

2906: END IF;
2907:
2908: -- call START_ACTIVITY to create savepoint, check compatibility
2909: -- and initialize message list
2910: x_return_status := OKC_API.START_ACTIVITY(
2911: p_api_name => l_api_name,
2912: p_pkg_name => G_PKG_NAME,
2913: p_init_msg_list => p_init_msg_list,
2914: l_api_version => l_api_version,

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

2916: p_api_type => G_API_TYPE,
2917: x_return_status => x_return_status);
2918:
2919: -- check if activity started successfully
2920: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
2921: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2922: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
2923: raise OKC_API.G_EXCEPTION_ERROR;
2924: END IF;

Line 2921: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2917: x_return_status => x_return_status);
2918:
2919: -- check if activity started successfully
2920: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
2921: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2922: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
2923: raise OKC_API.G_EXCEPTION_ERROR;
2924: END IF;
2925:

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

2918:
2919: -- check if activity started successfully
2920: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
2921: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2922: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
2923: raise OKC_API.G_EXCEPTION_ERROR;
2924: END IF;
2925:
2926: --++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

Line 2923: raise OKC_API.G_EXCEPTION_ERROR;

2919: -- check if activity started successfully
2920: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
2921: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2922: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
2923: raise OKC_API.G_EXCEPTION_ERROR;
2924: END IF;
2925:
2926: --++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
2927:

Line 2940: p_init_msg_list => OKC_API.G_FALSE,

2936:
2937: IF (i > 0) THEN
2938: okl_rule_pub.delete_rule(
2939: p_api_version => 1.0,
2940: p_init_msg_list => OKC_API.G_FALSE,
2941: x_return_status => x_return_status,
2942: x_msg_count => x_msg_count,
2943: x_msg_data => x_msg_data,
2944: p_rulv_tbl => l_rulv_tbl

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

2942: x_msg_count => x_msg_count,
2943: x_msg_data => x_msg_data,
2944: p_rulv_tbl => l_rulv_tbl
2945: );
2946: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
2947: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2948: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
2949: raise OKC_API.G_EXCEPTION_ERROR;
2950: END IF;

Line 2947: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2943: x_msg_data => x_msg_data,
2944: p_rulv_tbl => l_rulv_tbl
2945: );
2946: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
2947: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2948: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
2949: raise OKC_API.G_EXCEPTION_ERROR;
2950: END IF;
2951:

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

2944: p_rulv_tbl => l_rulv_tbl
2945: );
2946: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
2947: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2948: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
2949: raise OKC_API.G_EXCEPTION_ERROR;
2950: END IF;
2951:
2952: END IF;

Line 2949: raise OKC_API.G_EXCEPTION_ERROR;

2945: );
2946: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
2947: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2948: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
2949: raise OKC_API.G_EXCEPTION_ERROR;
2950: END IF;
2951:
2952: END IF;
2953:

Line 2965: p_init_msg_list => OKC_API.G_FALSE,

2961:
2962: l_rulv_rec.id := p_rule_id; -- SLH Rule ID
2963: okl_rule_pub.delete_rule(
2964: p_api_version => 1.0,
2965: p_init_msg_list => OKC_API.G_FALSE,
2966: x_return_status => x_return_status,
2967: x_msg_count => x_msg_count,
2968: x_msg_data => x_msg_data,
2969: p_rulv_rec => l_rulv_rec

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

2967: x_msg_count => x_msg_count,
2968: x_msg_data => x_msg_data,
2969: p_rulv_rec => l_rulv_rec
2970: );
2971: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
2972: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2973: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
2974: raise OKC_API.G_EXCEPTION_ERROR;
2975: END IF;

Line 2972: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2968: x_msg_data => x_msg_data,
2969: p_rulv_rec => l_rulv_rec
2970: );
2971: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
2972: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2973: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
2974: raise OKC_API.G_EXCEPTION_ERROR;
2975: END IF;
2976:

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

2969: p_rulv_rec => l_rulv_rec
2970: );
2971: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
2972: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2973: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
2974: raise OKC_API.G_EXCEPTION_ERROR;
2975: END IF;
2976:
2977: END IF;

Line 2974: raise OKC_API.G_EXCEPTION_ERROR;

2970: );
2971: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
2972: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2973: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
2974: raise OKC_API.G_EXCEPTION_ERROR;
2975: END IF;
2976:
2977: END IF;
2978:

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

2993: x_msg_data => x_msg_data,
2994: p_rgpv_rec => l_rgpv_rec
2995: );
2996:
2997: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
2998: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2999: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
3000: raise OKC_API.G_EXCEPTION_ERROR;
3001: END IF;

Line 2998: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2994: p_rgpv_rec => l_rgpv_rec
2995: );
2996:
2997: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
2998: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2999: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
3000: raise OKC_API.G_EXCEPTION_ERROR;
3001: END IF;
3002:

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

2995: );
2996:
2997: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
2998: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2999: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
3000: raise OKC_API.G_EXCEPTION_ERROR;
3001: END IF;
3002:
3003: END IF;

Line 3000: raise OKC_API.G_EXCEPTION_ERROR;

2996:
2997: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
2998: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2999: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
3000: raise OKC_API.G_EXCEPTION_ERROR;
3001: END IF;
3002:
3003: END IF;
3004:

Line 3013: when OKC_API.G_EXCEPTION_ERROR then

3009: x_msg_data => x_msg_data);
3010:
3011:
3012: EXCEPTION
3013: when OKC_API.G_EXCEPTION_ERROR then
3014: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
3015: p_api_name => l_api_name,
3016: p_pkg_name => G_PKG_NAME,
3017: p_exc_name => 'OKC_API.G_RET_STS_ERROR',

Line 3014: x_return_status := OKC_API.HANDLE_EXCEPTIONS(

3010:
3011:
3012: EXCEPTION
3013: when OKC_API.G_EXCEPTION_ERROR then
3014: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
3015: p_api_name => l_api_name,
3016: p_pkg_name => G_PKG_NAME,
3017: p_exc_name => 'OKC_API.G_RET_STS_ERROR',
3018: x_msg_count => x_msg_count,

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

3013: when OKC_API.G_EXCEPTION_ERROR then
3014: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
3015: p_api_name => l_api_name,
3016: p_pkg_name => G_PKG_NAME,
3017: p_exc_name => 'OKC_API.G_RET_STS_ERROR',
3018: x_msg_count => x_msg_count,
3019: x_msg_data => x_msg_data,
3020: p_api_type => G_API_TYPE);
3021:

Line 3022: when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then

3018: x_msg_count => x_msg_count,
3019: x_msg_data => x_msg_data,
3020: p_api_type => G_API_TYPE);
3021:
3022: when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
3023: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
3024: p_api_name => l_api_name,
3025: p_pkg_name => G_PKG_NAME,
3026: p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 3023: x_return_status := OKC_API.HANDLE_EXCEPTIONS(

3019: x_msg_data => x_msg_data,
3020: p_api_type => G_API_TYPE);
3021:
3022: when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
3023: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
3024: p_api_name => l_api_name,
3025: p_pkg_name => G_PKG_NAME,
3026: p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
3027: x_msg_count => x_msg_count,

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

3022: when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
3023: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
3024: p_api_name => l_api_name,
3025: p_pkg_name => G_PKG_NAME,
3026: p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
3027: x_msg_count => x_msg_count,
3028: x_msg_data => x_msg_data,
3029: p_api_type => G_API_TYPE);
3030:

Line 3032: x_return_status := OKC_API.HANDLE_EXCEPTIONS(

3028: x_msg_data => x_msg_data,
3029: p_api_type => G_API_TYPE);
3030:
3031: when OTHERS then
3032: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
3033: p_api_name => l_api_name,
3034: p_pkg_name => G_PKG_NAME,
3035: p_exc_name => 'OTHERS',
3036: x_msg_count => x_msg_count,