[Home] [Help]
1: PACKAGE BODY AME_ENGINE as
2: /* $Header: ameeengi.pkb 120.60.12020000.3 2013/02/14 10:49:49 nivsubra ship $ */
3: /*************************************************************************************
4: package variables
5: All engine package variables' names begin with the prefix 'eng'. All engine package
563: end if;
564: return(false);
565: exception
566: when others then
567: ame_util.runtimeException(packageNameIn => 'ame_engine',
568: routineNameIn => 'approversMatch',
569: exceptionNumberIn => sqlcode,
570: exceptionStringIn => sqlerrm);
571: raise;
648: return(engAttributeValues1(engAttributeValueIndexes(attributeIdIn)));
649: end if;
650: exception
651: when others then
652: ame_util.runtimeException(packageNameIn => 'ame_engine',
653: routineNameIn => 'getVariantAttributeValue',
654: exceptionNumberIn => sqlcode,
655: exceptionStringIn => sqlerrm);
656: raise;
664: itemClassIn => itemClassIn,
665: itemIdIn => itemIdIn));
666: exception
667: when others then
668: ame_util.runtimeException(packageNameIn => 'ame_engine',
669: routineNameIn => 'getVariantAttributeValue2',
670: exceptionNumberIn => sqlcode,
671: exceptionStringIn => sqlerrm);
672: raise;
881: when attributeTypeException then
882: errorCode := -20001;
883: errorMessage := ame_util.getMessage(applicationShortNameIn =>'PER',
884: messageNameIn => 'AME_400113_ENG_ATTR_UNREG_TYPE');
885: ame_util.runtimeException(packageNameIn => 'ame_engine',
886: routineNameIn => 'conditionIsSatisfied',
887: exceptionNumberIn => errorCode,
888: exceptionStringIn => errorMessage);
889: raise_application_error(errorCode,
889: raise_application_error(errorCode,
890: errorMessage);
891: return(null);
892: when others then
893: ame_util.runtimeException(packageNameIn => 'ame_engine',
894: routineNameIn => 'conditionIsSatisfied',
895: exceptionNumberIn => sqlcode,
896: exceptionStringIn => sqlerrm);
897: raise;
901: begin
902: return(engEvalPrioritiesPerItem);
903: exception
904: when others then
905: ame_util.runtimeException(packageNameIn => 'ame_engine',
906: routineNameIn => 'evalPrioritiesPerItem',
907: exceptionNumberIn => sqlcode,
908: exceptionStringIn => sqlerrm);
909: raise;
920: end loop;
921: return(false);
922: exception
923: when others then
924: ame_util.runtimeException(packageNameIn => 'ame_engine',
925: routineNameIn => 'insertionExists',
926: exceptionNumberIn => sqlcode,
927: exceptionStringIn => sqlerrm);
928: raise;
932: begin
933: return(engIsLocalTransaction);
934: exception
935: when others then
936: ame_util.runtimeException(packageNameIn => 'ame_engine',
937: routineNameIn => 'isLocalTransaction',
938: exceptionNumberIn => sqlcode,
939: exceptionStringIn => sqlerrm);
940: raise;
947: end if;
948: return(false);
949: exception
950: when others then
951: ame_util.runtimeException(packageNameIn => 'ame_engine',
952: routineNameIn => 'isStaticAttUsage',
953: exceptionNumberIn => sqlcode,
954: exceptionStringIn => sqlerrm);
955: raise;
959: begin
960: return(engIsTestTransaction);
961: exception
962: when others then
963: ame_util.runtimeException(packageNameIn => 'ame_engine',
964: routineNameIn => 'isTestTransaction',
965: exceptionNumberIn => sqlcode,
966: exceptionStringIn => sqlerrm);
967: raise;
978: end if;
979: return false;
980: exception
981: when others then
982: ame_util.runtimeException(packageNameIn => 'ame_engine',
983: routineNameIn => 'isVariant',
984: exceptionNumberIn => sqlcode,
985: exceptionStringIn => sqlerrm);
986: raise;
990: begin
991: return(engProcessPriorities);
992: exception
993: when others then
994: ame_util.runtimeException(packageNameIn => 'ame_engine',
995: routineNameIn => 'processPriorities',
996: exceptionNumberIn => sqlcode,
997: exceptionStringIn => sqlerrm);
998: raise;
1002: begin
1003: return(engProcessProductionActions);
1004: exception
1005: when others then
1006: ame_util.runtimeException(packageNameIn => 'ame_engine',
1007: routineNameIn => 'processProductionActions',
1008: exceptionNumberIn => sqlcode,
1009: exceptionStringIn => sqlerrm);
1010: raise;
1014: begin
1015: return(engProcessProductionRules);
1016: exception
1017: when others then
1018: ame_util.runtimeException(packageNameIn => 'ame_engine',
1019: routineNameIn => 'processProductionRules',
1020: exceptionNumberIn => sqlcode,
1021: exceptionStringIn => sqlerrm);
1022: raise;
1041: rownum < 2; /* Avoids second fetch otherwise required by ANSI standard to check for too many rows. */
1042: return(ameApplicationId);
1043: exception
1044: when others then
1045: ame_util.runtimeException(packageNameIn => 'ame_engine',
1046: routineNameIn => 'fetchAmeApplicationId',
1047: exceptionNumberIn => sqlcode,
1048: exceptionStringIn => sqlerrm);
1049: raise;
1054: begin
1055: return(engActionTypeChainOrderModes(actionTypeIdIn));
1056: exception
1057: when others then
1058: ame_util.runtimeException(packageNameIn => 'ame_engine',
1059: routineNameIn => 'getActionTypeChainOrderMode',
1060: exceptionNumberIn => sqlcode,
1061: exceptionStringIn => sqlerrm);
1062: raise;
1074: end loop;
1075: return(null);
1076: exception
1077: when others then
1078: ame_util.runtimeException(packageNameIn => 'ame_engine',
1079: routineNameIn => 'getActionTypeId',
1080: exceptionNumberIn => sqlcode,
1081: exceptionStringIn => sqlerrm);
1082: raise;
1089: end if;
1090: return(engActionTypeNames(actionTypeIdIn));
1091: exception
1092: when others then
1093: ame_util.runtimeException(packageNameIn => 'ame_engine',
1094: routineNameIn => 'getActionTypeName',
1095: exceptionNumberIn => sqlcode,
1096: exceptionStringIn => sqlerrm);
1097: raise;
1101: begin
1102: return(engActionTypeOrderNumbers(actionTypeIdIn));
1103: exception
1104: when others then
1105: ame_util.runtimeException(packageNameIn => 'ame_engine',
1106: routineNameIn => 'getActionTypeOrderNumber',
1107: exceptionNumberIn => sqlcode,
1108: exceptionStringIn => sqlerrm);
1109: raise;
1113: begin
1114: return(engActionTypePackageNames(actionTypeIdIn));
1115: exception
1116: when others then
1117: ame_util.runtimeException(packageNameIn => 'ame_engine',
1118: routineNameIn => 'getActionTypePackageName',
1119: exceptionNumberIn => sqlcode,
1120: exceptionStringIn => sqlerrm);
1121: raise;
1125: begin /* getActionTypeUsage returns the rule type that uses the input action type. */
1126: return(engActionTypeUsages(actionTypeIdIn));
1127: exception
1128: when others then
1129: ame_util.runtimeException(packageNameIn => 'ame_engine',
1130: routineNameIn => 'getActionTypeUsage',
1131: exceptionNumberIn => sqlcode,
1132: exceptionStringIn => sqlerrm);
1133: raise;
1140: end if;
1141: return(engActionTypeVotingRegimes(actionTypeIdIn));
1142: exception
1143: when others then
1144: ame_util.runtimeException(packageNameIn => 'ame_engine',
1145: routineNameIn => 'getActionTypeVotingRegime',
1146: exceptionNumberIn => sqlcode,
1147: exceptionStringIn => sqlerrm);
1148: raise;
1152: begin
1153: return(engAmeApplicationId);
1154: exception
1155: when others then
1156: ame_util.runtimeException(packageNameIn => 'ame_engine',
1157: routineNameIn => 'getAmeApplicationId',
1158: exceptionNumberIn => sqlcode,
1159: exceptionStringIn => sqlerrm);
1160: raise;
1164: begin
1165: return(engStApprovalProcessCompleteYN);
1166: exception
1167: when others then
1168: ame_util.runtimeException(packageNameIn => 'ame_engine',
1169: routineNameIn => 'getApprovalProcessCompleteYN',
1170: exceptionNumberIn => sqlcode,
1171: exceptionStringIn => sqlerrm);
1172: raise;
1194: errorMessage := ame_util.getMessage(applicationShortNameIn =>'PER',
1195: messageNameIn => 'AME_400680_NO_ID_FOR_ATTR',
1196: tokenNameOneIn => 'ATTRIBUTE_NAME',
1197: tokenValueOneIn => attributeNameIn);
1198: ame_util.runtimeException(packageNameIn => 'ame_engine',
1199: routineNameIn => 'getAttributeIdByName',
1200: exceptionNumberIn => errorCode,
1201: exceptionStringIn => errorMessage);
1202: raise_application_error(errorCode, errorMessage);
1201: exceptionStringIn => errorMessage);
1202: raise_application_error(errorCode, errorMessage);
1203: return(null);
1204: when others then
1205: ame_util.runtimeException(packageNameIn => 'ame_engine',
1206: routineNameIn => 'getAttributeIdByName',
1207: exceptionNumberIn => sqlcode,
1208: exceptionStringIn => attributeNameIn || ': ' || sqlerrm);
1209: raise;
1213: begin
1214: return(engAttributeNames(attributeIdIn));
1215: exception
1216: when others then
1217: ame_util.runtimeException(packageNameIn => 'ame_engine',
1218: routineNameIn => 'getAttributeName',
1219: exceptionNumberIn => sqlcode,
1220: exceptionStringIn => sqlerrm);
1221: raise;
1225: begin
1226: return(engAttributeTypes(attributeIdIn));
1227: exception
1228: when others then
1229: ame_util.runtimeException(packageNameIn => 'ame_engine',
1230: routineNameIn => 'getAttributeType',
1231: exceptionNumberIn => sqlcode,
1232: exceptionStringIn => sqlerrm);
1233: raise;
1250: errorMessage := ame_util.getMessage(applicationShortNameIn => 'PER',
1251: messageNameIn => 'AME_400114_ENG_INV_CON_VAR',
1252: tokenNameOneIn => 'CONFIG_VAR',
1253: tokenValueOneIn => configVarNameIn);
1254: ame_util.runtimeException(packageNameIn => 'ame_engine',
1255: routineNameIn => 'getConfigVarValue',
1256: exceptionNumberIn => errorCode,
1257: exceptionStringIn => errorMessage);
1258: raise_application_error(errorCode,
1257: exceptionStringIn => errorMessage);
1258: raise_application_error(errorCode,
1259: errorMessage);
1260: when others then
1261: ame_util.runtimeException(packageNameIn => 'ame_engine',
1262: routineNameIn => 'getConfigVarValue',
1263: exceptionNumberIn => sqlcode,
1264: exceptionStringIn => sqlerrm);
1265: raise;
1269: begin
1270: return(engEffectiveRuleDate);
1271: exception
1272: when others then
1273: ame_util.runtimeException(packageNameIn => 'ame_engine',
1274: routineNameIn => 'getEffectiveRuleDate',
1275: exceptionNumberIn => sqlcode,
1276: exceptionStringIn => sqlerrm);
1277: raise;
1281: begin
1282: return(engFndApplicationId);
1283: exception
1284: when others then
1285: ame_util.runtimeException(packageNameIn => 'ame_engine',
1286: routineNameIn => 'getFndApplicationId',
1287: exceptionNumberIn => sqlcode,
1288: exceptionStringIn => sqlerrm);
1289: raise;
1330: when badArgsException then
1331: errorCode := -20001;
1332: errorMessage := ame_util.getMessage(applicationShortNameIn =>'PER',
1333: messageNameIn => 'AME_400115_ENG_INV_VAL_ARG');
1334: ame_util.runtimeException(packageNameIn => 'ame_engine',
1335: routineNameIn => 'getForwardingBehavior',
1336: exceptionNumberIn => errorCode,
1337: exceptionStringIn => errorMessage);
1338: raise_application_error(errorCode,
1338: raise_application_error(errorCode,
1339: errorMessage);
1340: return(null);
1341: when others then
1342: ame_util.runtimeException(packageNameIn => 'ame_engine',
1343: routineNameIn => 'getForwardingBehavior',
1344: exceptionNumberIn => sqlcode,
1345: exceptionStringIn => sqlerrm);
1346: raise;
1350: begin
1351: return(engAppActionTypeIds(engAppHandlerFirstIndex));
1352: exception
1353: when others then
1354: ame_util.runtimeException(packageNameIn => 'ame_engine',
1355: routineNameIn => 'getHandlerActionTypeId',
1356: exceptionNumberIn => sqlcode,
1357: exceptionStringIn => sqlerrm);
1358: raise;
1362: begin
1363: return(engActionTypeOrderNumbers(engAppActionTypeIds(engAppHandlerFirstIndex)));
1364: exception
1365: when others then
1366: ame_util.runtimeException(packageNameIn => 'ame_engine',
1367: routineNameIn => 'getHandlerActionTypeOrderNum',
1368: exceptionNumberIn => sqlcode,
1369: exceptionStringIn => sqlerrm);
1370: raise;
1389: not isInsertionapprover then
1390: l_action_type_id := approverIn.action_type_id;
1391: l_action_type_name := getActionTypeName(l_action_type_id);
1392: if l_action_type_name not in (ame_util.postApprovalTypeName,ame_util.preApprovalTypeName ) then
1393: l_votingRegime := ame_engine.getActionTypeVotingRegime(actionTypeIdIn => approverIn.action_type_id);
1394: else
1395: l_votingRegime := votingRegimeIn;
1396: end if;
1397: if l_votingRegime = ame_util.firstApproverVoting then
1415: end if;
1416: return(null);
1417: exception
1418: when others then
1419: ame_util.runtimeException(packageNameIn => 'ame_engine',
1420: routineNameIn => 'getHandlerApprovalStatus',
1421: exceptionNumberIn => sqlcode,
1422: exceptionStringIn => sqlerrm);
1423: raise;
1443: when badRuleTypeException then
1444: errorCode := -20001;
1445: errorMessage := ame_util.getMessage(applicationShortNameIn =>'PER',
1446: messageNameIn => 'AME_400681_INV_HANDLER_RUL_TYP');
1447: ame_util.runtimeException(packageNameIn => 'ame_engine',
1448: routineNameIn => 'getHandlerAuthority',
1449: exceptionNumberIn => errorCode,
1450: exceptionStringIn => errorMessage);
1451: raise_application_error(errorCode,
1451: raise_application_error(errorCode,
1452: errorMessage);
1453: return(null);
1454: when others then
1455: ame_util.runtimeException(packageNameIn => 'ame_engine',
1456: routineNameIn => 'getHandlerAuthority',
1457: exceptionNumberIn => sqlcode,
1458: exceptionStringIn => sqlerrm);
1459: raise;
1463: begin
1464: return(engAppRuleItemClassIds(engAppHandlerFirstIndex));
1465: exception
1466: when others then
1467: ame_util.runtimeException(packageNameIn => 'ame_engine',
1468: routineNameIn => 'getHandlerItemClassId',
1469: exceptionNumberIn => sqlcode,
1470: exceptionStringIn => sqlerrm);
1471: raise;
1475: begin
1476: return(getItemClassName(itemClassIdIn => engAppRuleItemClassIds(engAppHandlerFirstIndex)));
1477: exception
1478: when others then
1479: ame_util.runtimeException(packageNameIn => 'ame_engine',
1480: routineNameIn => 'getHandlerItemClassName',
1481: exceptionNumberIn => sqlcode,
1482: exceptionStringIn => sqlerrm);
1483: raise;
1487: begin
1488: return(engItemClassOrderNumbers(engItemClassIndexes(engAppRuleItemClassIds(engAppHandlerFirstIndex))));
1489: exception
1490: when others then
1491: ame_util.runtimeException(packageNameIn => 'ame_engine',
1492: routineNameIn => 'getHandlerItemClassOrderNumber',
1493: exceptionNumberIn => sqlcode,
1494: exceptionStringIn => sqlerrm);
1495: raise;
1499: begin
1500: return(engAppAppItemIds(engAppHandlerFirstIndex));
1501: exception
1502: when others then
1503: ame_util.runtimeException(packageNameIn => 'ame_engine',
1504: routineNameIn => 'getHandlerItemId',
1505: exceptionNumberIn => sqlcode,
1506: exceptionStringIn => sqlerrm);
1507: raise;
1517: itemIdIn => engAppAppItemIds(engAppHandlerFirstIndex)));
1518: end if;
1519: exception
1520: when others then
1521: ame_util.runtimeException(packageNameIn => 'ame_engine',
1522: routineNameIn => 'getHandlerItemOrderNumber',
1523: exceptionNumberIn => sqlcode,
1524: exceptionStringIn => sqlerrm);
1525: raise;
1602: end loop;
1603: return(occurrence);
1604: exception
1605: when others then
1606: ame_util.runtimeException(packageNameIn => 'ame_engine',
1607: routineNameIn => 'getHandlerOccurrence',
1608: exceptionNumberIn => sqlcode,
1609: exceptionStringIn => sqlerrm);
1610: raise;
1614: begin
1615: return(engAppRuleTypes(engAppHandlerFirstIndex));
1616: exception
1617: when others then
1618: ame_util.runtimeException(packageNameIn => 'ame_engine',
1619: routineNameIn => 'getHandlerRuleType',
1620: exceptionNumberIn => sqlcode,
1621: exceptionStringIn => sqlerrm);
1622: raise;
1642: exception
1643: when no_data_found then
1644: return(null);
1645: when others then
1646: ame_util.runtimeException(packageNameIn => 'ame_engine',
1647: routineNameIn => 'getHandlerState',
1648: exceptionNumberIn => sqlcode,
1649: exceptionStringIn => sqlerrm);
1650: raise;
1680: end if;
1681: end if;
1682: exception
1683: when others then
1684: ame_util.runtimeException(packageNameIn => 'ame_engine',
1685: routineNameIn => 'getHandlerSublistOrderNum',
1686: exceptionNumberIn => sqlcode,
1687: exceptionStringIn => sqlerrm);
1688: raise;
1692: begin
1693: return(engAttributeValues1(engAttributeValueIndexes(attributeIdIn)));
1694: exception
1695: when others then
1696: ame_util.runtimeException(packageNameIn => 'ame_engine',
1697: routineNameIn => 'getHeaderAttValue1',
1698: exceptionNumberIn => sqlcode,
1699: exceptionStringIn => sqlerrm);
1700: raise;
1725: and item_id = engTransactionId;
1726: return tempValue;
1727: exception
1728: when others then
1729: ame_util.runtimeException(packageNameIn => 'ame_engine',
1730: routineNameIn => 'getTestVariantAttValue',
1731: exceptionNumberIn => sqlcode,
1732: exceptionStringIn => sqlerrm);
1733: raise;
1733: raise;
1734: return(null);
1735: end;
1736: when others then
1737: ame_util.runtimeException(packageNameIn => 'ame_engine',
1738: routineNameIn => 'getTestVariantAttValue',
1739: exceptionNumberIn => sqlcode,
1740: exceptionStringIn => sqlerrm);
1741: raise;
1763: end if;
1764: end if;
1765: exception
1766: when others then
1767: ame_util.runtimeException(packageNameIn => 'ame_engine',
1768: routineNameIn => 'getHeaderAttValue2',
1769: exceptionNumberIn => sqlcode,
1770: exceptionStringIn => sqlerrm);
1771: raise;
1778: getItemOffset(itemClassIdIn => engAttributeItemClassIds(attributeIdIn),
1779: itemIdIn => itemIdIn)));
1780: exception
1781: when others then
1782: ame_util.runtimeException(packageNameIn => 'ame_engine',
1783: routineNameIn => 'getItemAttValue1',
1784: exceptionNumberIn => sqlcode,
1785: exceptionStringIn => sqlerrm);
1786: raise;
1795: getItemOffset(itemClassIdIn => engAttributeItemClassIds(attributeId),
1796: itemIdIn => itemIdIn)));
1797: exception
1798: when others then
1799: ame_util.runtimeException(packageNameIn => 'ame_engine',
1800: routineNameIn => 'getItemAttValue2',
1801: exceptionNumberIn => sqlcode,
1802: exceptionStringIn => sqlerrm);
1803: raise;
1812: end loop;
1813: return(null);
1814: exception
1815: when others then
1816: ame_util.runtimeException(packageNameIn => 'ame_engine',
1817: routineNameIn => 'getItemClassId',
1818: exceptionNumberIn => sqlcode,
1819: exceptionStringIn => sqlerrm);
1820: raise;
1824: begin
1825: return(engItemClassNames(engItemClassIndexes(itemClassIdIn)));
1826: exception
1827: when others then
1828: ame_util.runtimeException(packageNameIn => 'ame_engine',
1829: routineNameIn => 'getItemClassName',
1830: exceptionNumberIn => sqlcode,
1831: exceptionStringIn => sqlerrm);
1832: raise;
1836: begin
1837: return(engItemClassOrderNumbers(engItemClassIndexes(itemClassIdIn)));
1838: exception
1839: when others then
1840: ame_util.runtimeException(packageNameIn => 'ame_engine',
1841: routineNameIn => 'getItemClassOrderNumber',
1842: exceptionNumberIn => sqlcode,
1843: exceptionStringIn => sqlerrm);
1844: raise;
1848: begin
1849: return(engItemClassParModes(engItemClassIndexes(itemClassIdIn)));
1850: exception
1851: when others then
1852: ame_util.runtimeException(packageNameIn => 'ame_engine',
1853: routineNameIn => 'getItemClassParMode',
1854: exceptionNumberIn => sqlcode,
1855: exceptionStringIn => sqlerrm);
1856: raise;
1860: begin
1861: return(engItemClassSublistModes(engItemClassIndexes(itemClassIdIn)));
1862: exception
1863: when others then
1864: ame_util.runtimeException(packageNameIn => 'ame_engine',
1865: routineNameIn => 'getItemClassSublistMode',
1866: exceptionNumberIn => sqlcode,
1867: exceptionStringIn => sqlerrm);
1868: raise;
1888: when noIndexException then
1889: errorCode := -20001;
1890: errorMessage := ame_util.getMessage(applicationShortNameIn =>'PER',
1891: messageNameIn => 'AME_400682_ENG_INV_ITEM_OFFSET');
1892: ame_util.runtimeException(packageNameIn => 'ame_engine',
1893: routineNameIn => 'getItemIndex',
1894: exceptionNumberIn => errorCode,
1895: exceptionStringIn => errorMessage);
1896: raise_application_error(errorCode,
1896: raise_application_error(errorCode,
1897: errorMessage);
1898: return(null);
1899: when others then
1900: ame_util.runtimeException(packageNameIn => 'ame_engine',
1901: routineNameIn => 'getItemIndex',
1902: exceptionNumberIn => sqlcode,
1903: exceptionStringIn => sqlerrm);
1904: raise;
1924: when noOffsetException then
1925: errorCode := -20001;
1926: errorMessage := ame_util.getMessage(applicationShortNameIn =>'PER',
1927: messageNameIn => 'AME_400682_ENG_INV_ITEM_OFFSET');
1928: ame_util.runtimeException(packageNameIn => 'ame_engine',
1929: routineNameIn => 'getItemOffset',
1930: exceptionNumberIn => errorCode,
1931: exceptionStringIn => errorMessage);
1932: raise_application_error(errorCode,
1932: raise_application_error(errorCode,
1933: errorMessage);
1934: return(null);
1935: when others then
1936: ame_util.runtimeException(packageNameIn => 'ame_engine',
1937: routineNameIn => 'getItemOffset',
1938: exceptionNumberIn => sqlcode,
1939: exceptionStringIn => sqlerrm);
1940: raise;
1952: itemIdIn => itemIdIn));
1953: end if;
1954: exception
1955: when others then
1956: ame_util.runtimeException(packageNameIn => 'ame_engine',
1957: routineNameIn => 'getItemOrderNumber',
1958: exceptionNumberIn => sqlcode,
1959: exceptionStringIn => sqlerrm);
1960: raise;
1975: return (maxInsertionOrderNumber + 1);
1976: end if;
1977: exception
1978: when others then
1979: ame_util.runtimeException(packageNameIn => 'ame_engine',
1980: routineNameIn => 'getNextInsertionOrder',
1981: exceptionNumberIn => sqlcode,
1982: exceptionStringIn => sqlerrm);
1983: raise;
1997: end loop;
1998: return(maxOrderNumber + 1);
1999: exception
2000: when others then
2001: ame_util.runtimeException(packageNameIn => 'ame_engine',
2002: routineNameIn => 'getNullActionTypeOrderNumber',
2003: exceptionNumberIn => sqlcode,
2004: exceptionStringIn => sqlerrm);
2005: raise;
2025: end if;
2026: end loop;
2027: exception
2028: when others then
2029: ame_util.runtimeException(packageNameIn => 'ame_engine',
2030: routineNameIn => 'getRuntimeGroupCount',
2031: exceptionNumberIn => sqlcode,
2032: exceptionStringIn => sqlerrm);
2033: raise;
2063: end if;
2064: end if;
2065: exception
2066: when others then
2067: ame_util.runtimeException(packageNameIn => 'ame_engine',
2068: routineNameIn => 'getSublistOrderNum',
2069: exceptionNumberIn => sqlcode,
2070: exceptionStringIn => sqlerrm);
2071: raise;
2075: begin
2076: return(engTransactionID);
2077: exception
2078: when others then
2079: ame_util.runtimeException(packageNameIn => 'ame_engine',
2080: routineNameIn => 'getTransactionId',
2081: exceptionNumberIn => sqlcode,
2082: exceptionStringIn => sqlerrm);
2083: raise;
2087: begin
2088: return(engTransactionTypeID);
2089: exception
2090: when others then
2091: ame_util.runtimeException(packageNameIn => 'ame_engine',
2092: routineNameIn => 'getTransactionTypeId',
2093: exceptionNumberIn => sqlcode,
2094: exceptionStringIn => sqlerrm);
2095: raise;
2177: end if;
2178: return(true);
2179: exception
2180: when others then
2181: ame_util.runtimeException(packageNameIn => 'ame_engine',
2182: routineNameIn => 'compareApplicableRules',
2183: exceptionNumberIn => sqlcode,
2184: exceptionStringIn => sqlerrm);
2185: raise;
2236: errorCode := -20001;
2237: errorMessage :=
2238: ame_util.getMessage(applicationShortNameIn => 'PER',
2239: messageNameIn => 'AME_400118_ENG_LOOP_CHA_AUTH');
2240: ame_util.runtimeException(packageNameIn => 'ame_engine',
2241: routineNameIn => 'addApprover',
2242: exceptionNumberIn => errorCode,
2243: exceptionStringIn => errorMessage);
2244: raise_application_error(errorCode,
2246: when nullFieldException then
2247: errorCode := -20001;
2248: errorMessage := ame_util.getMessage(applicationShortNameIn =>'PER',
2249: messageNameIn => 'AME_400683_APPR_REC_INV');
2250: ame_util.runtimeException(packageNameIn => 'ame_engine',
2251: routineNameIn => 'addApprover',
2252: exceptionNumberIn => errorCode,
2253: exceptionStringIn => errorMessage);
2254: raise_application_error(errorCode,
2253: exceptionStringIn => errorMessage);
2254: raise_application_error(errorCode,
2255: errorMessage);
2256: when others then
2257: ame_util.runtimeException(packageNameIn => 'ame_engine',
2258: routineNameIn => 'addApprover',
2259: exceptionNumberIn => sqlcode,
2260: exceptionStringIn => sqlerrm);
2261: raise;
2270: engTempReason := null;
2271: engTempDate := null;
2272: exception
2273: when others then
2274: ame_util.runtimeException(packageNameIn => 'ame_engine',
2275: routineNameIn => 'addApproversTodevList',
2276: exceptionNumberIn => sqlcode,
2277: exceptionStringIn => sqlerrm);
2278: end addApproversTodevList;
2436: end loop;
2437: addApproversTodevList(approverRecordIndexIn => approverIndexIn);
2438: exception
2439: when others then
2440: ame_util.runtimeException(packageNameIn => 'ame_engine',
2441: routineNameIn => 'addApproverToTree',
2442: exceptionNumberIn => sqlcode,
2443: exceptionStringIn => sqlerrm);
2444: raise;
2463: ,approvalStatusOut => transactionApprovalStatus
2464: ,rejectedItemsExistOut => transactionhasSuspendedItems);
2465: engStApproversTree(1).status := transactionApprovalStatus;
2466: engStApproversTree(1).max_order := maximumApproverOrderNumber;
2467: stoppingRule := ame_engine.getHeaderAttValue2
2468: (attributeNameIn => ame_util.rejectionResponseAttribute);
2469: if transactionhasSuspendedItems then
2470: /* Check if any of the suspended item is a header item */
2471: /* If a header item is suspended then it is as good as */
2519: end if;
2520: end if;
2521: exception
2522: when others then
2523: ame_util.runtimeException(packageNameIn => 'ame_engine',
2524: routineNameIn => 'calculateApproverOrderNumbers',
2525: exceptionNumberIn => sqlcode,
2526: exceptionStringIn => sqlerrm);
2527: raise;
2565: ||approverIn.display_name
2566: ||' belongs to approver type '
2567: ||approverIn.orig_system
2568: ||' which is not registered in AME.';
2569: ame_util.runtimeException(packageNameIn => 'ame_engine',
2570: routineNameIn => 'checkApprover',
2571: exceptionNumberIn => errorCode,
2572: exceptionStringIn => errorMessage);
2573: raise_application_error(errorCode,
2578: ||approverIn.display_name
2579: ||' belongs to approver type '
2580: ||approverIn.orig_system
2581: ||'. And the allowAllApproverTypes configuration variable set to No.';
2582: ame_util.runtimeException(packageNameIn => 'ame_engine',
2583: routineNameIn => 'checkApprover',
2584: exceptionNumberIn => errorCode,
2585: exceptionStringIn => errorMessage);
2586: raise_application_error(errorCode,
2600: ((parameter is null and parameterIn is null) or
2601: (parameter = parameterIn));
2602: exception
2603: when others then
2604: ame_util.runtimeException(packageNameIn => 'ame_engine',
2605: routineNameIn => 'clearHandlerState',
2606: exceptionNumberIn => sqlcode,
2607: exceptionStringIn => sqlerrm);
2608: raise;
2667: engAppParameterTwos.delete(tempFirstIndex, tempLastIndex);
2668: end if;
2669: exception
2670: when others then
2671: ame_util.runtimeException(packageNameIn => 'ame_engine',
2672: routineNameIn => 'compactEngAppLists',
2673: exceptionNumberIn => sqlcode,
2674: exceptionStringIn => sqlerrm);
2675: raise;
2850: end if;
2851: end loop;
2852: exception
2853: when others then
2854: ame_util.runtimeException(packageNameIn => 'ame_engine',
2855: routineNameIn => 'doPerItemRuleEvaluation',
2856: exceptionNumberIn => sqlcode,
2857: exceptionStringIn => sqlerrm);
2858: raise;
3008: end if;
3009: end loop;
3010: exception
3011: when others then
3012: ame_util.runtimeException(packageNameIn => 'ame_engine',
3013: routineNameIn => 'doStrictHeaderRuleEvaluation',
3014: exceptionNumberIn => sqlcode,
3015: exceptionStringIn => sqlerrm);
3016: raise;
3208: end if;
3209: end loop;
3210: exception
3211: when others then
3212: ame_util.runtimeException(packageNameIn => 'ame_engine',
3213: routineNameIn => 'doWeakHeaderRuleEvaluation',
3214: exceptionNumberIn => sqlcode,
3215: exceptionStringIn => sqlerrm);
3216: raise;
3473: if fnd_log.g_current_runtime_level <= fnd_log.level_statement then
3474: if engAppRuleIds.count = 0 then
3475: fnd_log.string
3476: (fnd_log.level_statement
3477: ,'ame_engine.evaluateRules'
3478: ,'*********** No Rules Applicable ************'
3479: );
3480: else
3481: for i in 1 .. engAppRuleIds.count loop
3480: else
3481: for i in 1 .. engAppRuleIds.count loop
3482: fnd_log.string
3483: (fnd_log.level_statement
3484: ,'ame_engine.evaluateRules'
3485: ,'Applicable Rule ::: ' || engAppRuleIds(i)
3486: );
3487: end loop;
3488: end if;
3496: when noRulesException then
3497: errorCode := -20102;
3498: errorMessage := ame_util.getMessage(applicationShortNameIn =>'PER',
3499: messageNameIn => 'AME_400117_ENG_ONE_RULE_APPLY');
3500: ame_util.runtimeException(packageNameIn => 'ame_engine',
3501: routineNameIn => 'evaluateRules',
3502: exceptionNumberIn => errorCode,
3503: exceptionStringIn => errorMessage);
3504: raise_application_error(errorCode,
3506: when others then
3507: if(conditionlessRuleCursor%isopen) then
3508: close conditionlessRuleCursor;
3509: end if;
3510: ame_util.runtimeException(packageNameIn => 'ame_engine',
3511: routineNameIn => 'evaluateRules',
3512: exceptionNumberIn => sqlcode,
3513: exceptionStringIn => sqlerrm);
3514: raise;
3802: end if;
3803: if(activeCondStringValueCursor%isopen) then
3804: close activeCondStringValueCursor;
3805: end if;
3806: ame_util.runtimeException(packageNameIn => 'ame_engine',
3807: routineNameIn => 'fetchActiveConditionUsages',
3808: exceptionNumberIn => sqlcode,
3809: exceptionStringIn => sqlerrm);
3810: raise;
3942: when others then
3943: if(applicableActionsCursor%isopen) then
3944: close applicableActionsCursor;
3945: end if;
3946: ame_util.runtimeException(packageNameIn => 'ame_engine',
3947: routineNameIn => 'fetchApplicableActions',
3948: exceptionNumberIn => sqlcode,
3949: exceptionStringIn => sqlerrm);
3950: raise;
4110: end if;
4111: if fnd_log.g_current_runtime_level <= fnd_log.level_statement then
4112: fnd_log.string
4113: (fnd_log.level_statement
4114: ,'ame_engine.fetchAttributeValues'
4115: ,'Attribute ::: ' || engAttributeNames(tempAttributeId) || '(' || tempAttributeId || ')'
4116: );
4117: end if;
4118: /*
4161: end if;
4162: if fnd_log.g_current_runtime_level <= fnd_log.level_statement then
4163: fnd_log.string
4164: (fnd_log.level_statement
4165: ,'ame_engine.fetchAttributeValues'
4166: ,'Attribute Value :' || engAttributeValues1(tempAttributeValueIndex) ||
4167: ':' || engAttributeValues2(tempAttributeValueIndex) || ':' || engAttributeValues3(tempAttributeValueIndex) || ':'
4168: );
4169: end if;
4176: engAttributeValues3(tempAttributeValueIndex) := null;
4177: if fnd_log.g_current_runtime_level <= fnd_log.level_statement then
4178: fnd_log.string
4179: (fnd_log.level_statement
4180: ,'ame_engine.fetchAttributeValues'
4181: ,'Attribute Value :' || engAttributeValues1(tempAttributeValueIndex) ||
4182: ':' || engAttributeValues2(tempAttributeValueIndex) || ':' || engAttributeValues3(tempAttributeValueIndex) || ':'
4183: );
4184: end if;
4210: engAttributeValues3(tempAttributeValueIndex) := tempAttributeValue3;
4211: if fnd_log.g_current_runtime_level <= fnd_log.level_statement then
4212: fnd_log.string
4213: (fnd_log.level_statement
4214: ,'ame_engine.fetchAttributeValues'
4215: ,'Attribute Value :' || engAttributeValues1(tempAttributeValueIndex) ||
4216: ':' || engAttributeValues2(tempAttributeValueIndex) || ':' || engAttributeValues3(tempAttributeValueIndex) || ':'
4217: );
4218: end if;
4300: end if;
4301: if fnd_log.g_current_runtime_level <= fnd_log.level_statement then
4302: fnd_log.string
4303: (fnd_log.level_statement
4304: ,'ame_engine.fetchAttributeValues'
4305: ,'Attribute Value :' || engAttributeValues1(tempAttributeValueIndex) ||
4306: ':' || engAttributeValues2(tempAttributeValueIndex) || ':' || engAttributeValues3(tempAttributeValueIndex) || ':'
4307: );
4308: end if;
4328: tempAttributeName := ame_attribute_pkg.getName(attributeIdIn => tempAttributeId);
4329: if fnd_log.g_current_runtime_level <= fnd_log.level_statement then
4330: fnd_log.string
4331: (fnd_log.level_statement
4332: ,'ame_engine.fetchAttributeValues'
4333: ,'Attribute ::: ' || tempAttributeName || '(' || tempAttributeId || ')'||
4334: 'attribute returned ::'||tempAttributeValues1.count||'rows but the number of items for the '||
4335: 'itemclass ::'||engItemCounts(tempItemClassIndex)
4336: );
4340: ame_util.getMessage(applicationShortNameIn =>'PER',
4341: messageNameIn => 'AME_400684_ATR_INV_DYN_USG',
4342: tokenNameOneIn => 'ATTRIBUTE_NAME',
4343: tokenValueOneIn => tempAttributeName);
4344: ame_util.runtimeException(packageNameIn => 'ame_engine',
4345: routineNameIn => 'fetchAttributeValues',
4346: exceptionNumberIn => errorCode,
4347: exceptionStringIn => errorMessage);
4348: raise_application_error(errorCode,
4364: errorMessage := sqlerrm;
4365: if fnd_log.g_current_runtime_level <= fnd_log.level_statement then
4366: fnd_log.string
4367: (fnd_log.level_statement
4368: ,'ame_engine.fetchAttributeValues'
4369: ,'Attribute ::: ' || tempAttributeName || '(' || tempAttributeId || '),error:'||errorMessage
4370: );
4371: end if;
4372: ame_util.runtimeException(packageNameIn => 'ame_engine',
4368: ,'ame_engine.fetchAttributeValues'
4369: ,'Attribute ::: ' || tempAttributeName || '(' || tempAttributeId || '),error:'||errorMessage
4370: );
4371: end if;
4372: ame_util.runtimeException(packageNameIn => 'ame_engine',
4373: routineNameIn => 'fetchAttributeValues',
4374: exceptionNumberIn => sqlcode,
4375: exceptionStringIn => errorMessage);
4376: raise;
4570: end if;
4571: if fnd_log.g_current_runtime_level <= fnd_log.level_statement then
4572: fnd_log.string
4573: (fnd_log.level_statement
4574: ,'ame_engine.fetchOtherAttributeValues'
4575: ,'Attribute ::: ' || engAttributeNames(tempAttributeId) || '(' || tempAttributeId || ')'
4576: );
4577: end if;
4578: /*
4621: end if;
4622: if fnd_log.g_current_runtime_level <= fnd_log.level_statement then
4623: fnd_log.string
4624: (fnd_log.level_statement
4625: ,'ame_engine.fetchOtherAttributeValues'
4626: ,'Attribute Value :' || engAttributeValues1(tempAttributeValueIndex) ||
4627: ':' || engAttributeValues2(tempAttributeValueIndex) || ':' || engAttributeValues3(tempAttributeValueIndex) || ':'
4628: );
4629: end if;
4636: engAttributeValues3(tempAttributeValueIndex) := null;
4637: if fnd_log.g_current_runtime_level <= fnd_log.level_statement then
4638: fnd_log.string
4639: (fnd_log.level_statement
4640: ,'ame_engine.fetchOtherAttributeValues'
4641: ,'Attribute Value :' || engAttributeValues1(tempAttributeValueIndex) ||
4642: ':' || engAttributeValues2(tempAttributeValueIndex) || ':' || engAttributeValues3(tempAttributeValueIndex) || ':'
4643: );
4644: end if;
4670: engAttributeValues3(tempAttributeValueIndex) := tempAttributeValue3;
4671: if fnd_log.g_current_runtime_level <= fnd_log.level_statement then
4672: fnd_log.string
4673: (fnd_log.level_statement
4674: ,'ame_engine.fetchOtherAttributeValues'
4675: ,'Attribute Value :' || engAttributeValues1(tempAttributeValueIndex) ||
4676: ':' || engAttributeValues2(tempAttributeValueIndex) || ':' || engAttributeValues3(tempAttributeValueIndex) || ':'
4677: );
4678: end if;
4760: end if;
4761: if fnd_log.g_current_runtime_level <= fnd_log.level_statement then
4762: fnd_log.string
4763: (fnd_log.level_statement
4764: ,'ame_engine.fetchOtherAttributeValues'
4765: ,'Attribute Value :' || engAttributeValues1(tempAttributeValueIndex) ||
4766: ':' || engAttributeValues2(tempAttributeValueIndex) || ':' || engAttributeValues3(tempAttributeValueIndex) || ':'
4767: );
4768: end if;
4791: ame_util.getMessage(applicationShortNameIn =>'PER',
4792: messageNameIn => 'AME_400684_ATR_INV_DYN_USG',
4793: tokenNameOneIn => 'ATTRIBUTE_NAME',
4794: tokenValueOneIn => tempAttributeName);
4795: ame_util.runtimeException(packageNameIn => 'ame_engine',
4796: routineNameIn => 'fetchOtherAttributeValues',
4797: exceptionNumberIn => errorCode,
4798: exceptionStringIn => errorMessage);
4799: raise_application_error(errorCode,
4810: end if;
4811: if(testTransNonCurrencyCursor%isopen) then
4812: close testTransNonCurrencyCursor;
4813: end if;
4814: ame_util.runtimeException(packageNameIn => 'ame_engine',
4815: routineNameIn => 'fetchOtherAttributeValues',
4816: exceptionNumberIn => sqlcode,
4817: exceptionStringIn => sqlerrm);
4818: raise;
4944: end if;
4945: if(configVarCursor%isopen) then
4946: close configVarCursor;
4947: end if;
4948: ame_util.runtimeException(packageNameIn => 'ame_engine',
4949: routineNameIn => 'fetchConfigVars',
4950: exceptionNumberIn => sqlcode,
4951: exceptionStringIn => sqlerrm);
4952: raise;
5007: when others then
5008: if(deletedApproversCursor%isopen) then
5009: close deletedApproversCursor;
5010: end if;
5011: ame_util.runtimeException(packageNameIn => 'ame_engine',
5012: routineNameIn => 'fetchDeletedApprovers',
5013: exceptionNumberIn => sqlcode,
5014: exceptionStringIn => sqlerrm);
5015: raise;
5080: when others then
5081: if(insertedApproversCursor%isopen) then
5082: close insertedApproversCursor;
5083: end if;
5084: ame_util.runtimeException(packageNameIn => 'ame_engine',
5085: routineNameIn => 'fetchInsertedApprovers',
5086: exceptionNumberIn => sqlcode,
5087: exceptionStringIn => sqlerrm);
5088: raise;
5236: end if;
5237: if fnd_log.g_current_runtime_level <= fnd_log.level_statement then
5238: fnd_log.string
5239: (fnd_log.level_statement
5240: ,'ame_engine.fetchItemClassData'
5241: ,'Item Class ::' || engItemClassNames(i) ||
5242: ':' || 'has ' || ':' || engItemCounts(i) || ':items'
5243: );
5244: end if;
5250: end if;
5251: if(testTransItemIdCursor%isopen) then
5252: close testTransItemIdCursor;
5253: end if;
5254: ame_util.runtimeException(packageNameIn => 'ame_engine',
5255: routineNameIn => 'fetchItemClassData',
5256: exceptionNumberIn => sqlcode,
5257: exceptionStringIn => sqlerrm);
5258: raise;
5276: nvl(end_date - ame_util.oneSecond, sysdate) and
5277: rownum < 2; /* Avoids second fetch otherwise required by ANSI standard to check for too many rows. */
5278: exception
5279: when others then
5280: ame_util.runtimeException(packageNameIn => 'ame_engine',
5281: routineNameIn => 'fetchFndApplicationId',
5282: exceptionNumberIn => sqlcode,
5283: exceptionStringIn => sqlerrm);
5284: fndApplicationIdOut := null;
5354: when others then
5355: if(oldApproversCursor%isopen) then
5356: close oldApproversCursor;
5357: end if;
5358: ame_util.runtimeException(packageNameIn => 'ame_engine',
5359: routineNameIn => 'fetchOldApprovers',
5360: exceptionNumberIn => sqlcode,
5361: exceptionStringIn => sqlerrm);
5362: raise;
5470: begin
5471: if fnd_log.g_current_runtime_level <= fnd_log.level_statement then
5472: fnd_log.string
5473: (fnd_log.level_statement
5474: ,'ame_engine.fetchRuntimeGroup'
5475: ,'evaluating the group::'||ame_approval_group_pkg.getName(approvalGroupIdIn => groupIdIn
5476: ,effectiveDateIn => engEffectiveRuleDate)
5477: );
5478: end if;
5622: errorCode := -20215;
5623: errorMessage := ame_util.getMessage(applicationShortNameIn =>'PER',
5624: messageNameIn => 'AME_400838_INV_APR_FOUND',
5625: tokenNameOneIn => 'PROCESS_NAME',
5626: tokenValueOneIn => 'ame_engine.fetchRuntimeGroup:'||ame_approval_group_pkg.getName
5627: (approvalGroupIdIn => groupIdIn,effectiveDateIn => engEffectiveRuleDate),
5628: tokenNameTwoIn => 'ORIG_SYSTEM',
5629: tokenValueTwoIn => tempApproverType,
5630: tokenNameThreeIn => 'ORIG_SYSEM_ID',
5652: errorCode := -20215;
5653: errorMessage := ame_util.getMessage(applicationShortNameIn =>'PER',
5654: messageNameIn => 'AME_400838_INV_APR_FOUND',
5655: tokenNameOneIn => 'PROCESS_NAME',
5656: tokenValueOneIn => 'ame_engine.fetchRuntimeGroup:'||ame_approval_group_pkg.getName
5657: (approvalGroupIdIn => groupIdIn,effectiveDateIn => engEffectiveRuleDate),
5658: tokenNameTwoIn => 'ORIG_SYSTEM',
5659: tokenValueTwoIn => tempApproverType,
5660: tokenNameThreeIn => 'ORIG_SYSEM_ID',
5693: errorCode := -20215;
5694: errorMessage := ame_util.getMessage(applicationShortNameIn =>'PER',
5695: messageNameIn => 'AME_400838_INV_APR_FOUND',
5696: tokenNameOneIn => 'PROCESS_NAME',
5697: tokenValueOneIn => 'ame_engine.fetchRuntimeGroup:'||ame_approval_group_pkg.getName
5698: (approvalGroupIdIn => groupIdIn,effectiveDateIn => engEffectiveRuleDate),
5699: tokenNameTwoIn => 'ORIG_SYSTEM',
5700: tokenValueTwoIn => origSystems(i),
5701: tokenNameThreeIn => 'ORIG_SYSEM_ID',
5712: end loop;
5713: if fnd_log.g_current_runtime_level <= fnd_log.level_statement then
5714: fnd_log.string
5715: (fnd_log.level_statement
5716: ,'ame_engine.fetchRuntimeGroup'
5717: ,'Completed the group evaluation::'||ame_approval_group_pkg.getName(approvalGroupIdIn => groupIdIn
5718: ,effectiveDateIn => engEffectiveRuleDate)
5719: );
5720: end if;
5725: messageNameIn => 'AME_400771_ENG_INVALID_DYN_GRP',
5726: tokenNameOneIn => 'GROUP_NAME',
5727: tokenValueOneIn => ame_approval_group_pkg.getName(approvalGroupIdIn => groupIdIn
5728: ,effectiveDateIn => engEffectiveRuleDate));
5729: ame_util.runtimeException(packageNameIn => 'ame_engine',
5730: routineNameIn => 'fetchRuntimeGroup',
5731: exceptionNumberIn => errorCode,
5732: exceptionStringIn => errorMessage);
5733: raise_application_error(errorCode,
5735: when others then
5736: if(groupMemberCursor%isopen) then
5737: close groupMemberCursor;
5738: end if;
5739: ame_util.runtimeException(packageNameIn => 'ame_engine',
5740: routineNameIn => 'fetchRuntimeGroup',
5741: exceptionNumberIn => sqlcode,
5742: exceptionStringIn => sqlerrm);
5743: raise;
5840: else
5841: engStApproversTree(currentTreeNodeIndex).min_order
5842: := maximumOrderOfChildren + 1;
5843: end if;
5844: ame_engine.finalizeTree
5845: (parentIndexIn => currentTreeNodeIndex
5846: ,maximumOrderOut => engStApproversTree(currentTreeNodeIndex).max_order
5847: ,approvalStatusOut => engStApproversTree(currentTreeNodeIndex).status
5848: ,rejectedItemsExistOut => hasRejectedChildren);
5888: end if;
5889: end if;
5890: exception
5891: when others then
5892: ame_util.runtimeException(packageNameIn => 'ame_engine',
5893: routineNameIn => 'finalizeTree',
5894: exceptionNumberIn => sqlcode,
5895: exceptionStringIn => sqlerrm);
5896: raise;
5903: transactionTypeIn => engTransactionTypeId,
5904: approversOut => approversOut);
5905: exception
5906: when others then
5907: ame_util.runtimeException(packageNameIn => 'ame_engine',
5908: routineNameIn => 'getAllApprovers',
5909: exceptionNumberIn => sqlcode,
5910: exceptionStringIn => sqlerrm);
5911: raise;
5939: end if;
5940: end loop;
5941: exception
5942: when others then
5943: ame_util.runtimeException(packageNameIn => 'ame_engine',
5944: routineNameIn => 'getApplicableRules',
5945: exceptionNumberIn => sqlcode,
5946: exceptionStringIn => sqlerrm);
5947: raise;
6014: when others then
6015: if(approvalGroupConfigCursor%isopen) then
6016: close approvalGroupConfigCursor;
6017: end if;
6018: ame_util.runtimeException(packageNameIn => 'ame_engine',
6019: routineNameIn => 'getApprovalGroupConfigs',
6020: exceptionNumberIn => sqlcode,
6021: exceptionStringIn => sqlerrm);
6022: raise;
6059: approversOut(i).approver_order_number := engStApprovers(i).approver_order_number;
6060: end loop;
6061: exception
6062: when others then
6063: ame_util.runtimeException(packageNameIn => 'ame_engine',
6064: routineNameIn => 'getApprovers',
6065: exceptionNumberIn => sqlcode,
6066: exceptionStringIn => sqlerrm);
6067: raise;
6114: end loop;
6115: end if;
6116: exception
6117: when others then
6118: ame_util.runtimeException(packageNameIn => 'ame_engine',
6119: routineNameIn => 'getApprovers2',
6120: exceptionNumberIn => sqlcode,
6121: exceptionStringIn => sqlerrm);
6122: raise;
6176: end if;
6177: end loop;
6178: exception
6179: when others then
6180: ame_util.runtimeException(packageNameIn => 'ame_engine',
6181: routineNameIn => 'getHandlerCOAFirstApprover',
6182: exceptionNumberIn => sqlcode,
6183: exceptionStringIn => sqlerrm);
6184: raise;
6253: end if;
6254: end loop;
6255: exception
6256: when others then
6257: ame_util.runtimeException(packageNameIn => 'ame_engine',
6258: routineNameIn => 'getHandlerCOAInsertion',
6259: exceptionNumberIn => sqlcode,
6260: exceptionStringIn => sqlerrm);
6261: raise;
6275: parameterTwosOut(outputIndex) := engAppParameterTwos(i);
6276: end loop;
6277: exception
6278: when others then
6279: ame_util.runtimeException(packageNameIn => 'ame_engine',
6280: routineNameIn => 'getHandlerRules',
6281: exceptionNumberIn => sqlcode,
6282: exceptionStringIn => sqlerrm);
6283: raise;
6295: parametersOut(outputIndex) := engAppParameters(i);
6296: end loop;
6297: exception
6298: when others then
6299: ame_util.runtimeException(packageNameIn => 'ame_engine',
6300: routineNameIn => 'getHandlerRules2',
6301: exceptionNumberIn => sqlcode,
6302: exceptionStringIn => sqlerrm);
6303: raise;
6320: parameterTwoOut => listModParameterTwosOut(outputIndex));
6321: end loop;
6322: exception
6323: when others then
6324: ame_util.runtimeException(packageNameIn => 'ame_engine',
6325: routineNameIn => 'getHandlerRules3',
6326: exceptionNumberIn => sqlcode,
6327: exceptionStringIn => sqlerrm);
6328: raise;
6408: end if;
6409: end loop;
6410: exception
6411: when others then
6412: ame_util.runtimeException(packageNameIn => 'ame_engine',
6413: routineNameIn => 'getHandlerLMApprovers',
6414: exceptionNumberIn => sqlcode,
6415: exceptionStringIn => sqlerrm);
6416: raise;
6426: attributeValue2Out := engAttributeValues2(attributeValueIndex);
6427: attributeValue3Out := engAttributeValues3(attributeValueIndex);
6428: exception
6429: when others then
6430: ame_util.runtimeException(packageNameIn => 'ame_engine',
6431: routineNameIn => 'getHeaderAttValues1',
6432: exceptionNumberIn => sqlcode,
6433: exceptionStringIn => sqlerrm);
6434: raise;
6453: attributeValue3Out := engAttributeValues3(attributeValueIndex);
6454: end if;
6455: exception
6456: when others then
6457: ame_util.runtimeException(packageNameIn => 'ame_engine',
6458: routineNameIn => 'getHeaderAttValues2',
6459: exceptionNumberIn => sqlcode,
6460: exceptionStringIn => sqlerrm);
6461: raise;
6466: itemAppProcessCompleteYNOut(i) := engStItemAppProcessCompleteYN(i);
6467: end loop;
6468: exception
6469: when others then
6470: ame_util.runtimeException(packageNameIn => 'ame_engine',
6471: routineNameIn => 'getItemAppProcessCompleteYN',
6472: exceptionNumberIn => sqlcode,
6473: exceptionStringIn => sqlerrm);
6474: raise;
6488: attributeValue2Out := engAttributeValues2(attributeValueIndex);
6489: attributeValue3Out := engAttributeValues3(attributeValueIndex);
6490: exception
6491: when others then
6492: ame_util.runtimeException(packageNameIn => 'ame_engine',
6493: routineNameIn => 'getItemAttValues1',
6494: exceptionNumberIn => sqlcode,
6495: exceptionStringIn => sqlerrm);
6496: raise;
6512: attributeValue2Out := engAttributeValues2(attributeValueIndex);
6513: attributeValue3Out := engAttributeValues3(attributeValueIndex);
6514: exception
6515: when others then
6516: ame_util.runtimeException(packageNameIn => 'ame_engine',
6517: routineNameIn => 'getItemAttValues2',
6518: exceptionNumberIn => sqlcode,
6519: exceptionStringIn => sqlerrm);
6520: raise;
6534: attributeValue2Out := engAttributeValues2(attributeValueIndex);
6535: attributeValue3Out := engAttributeValues3(attributeValueIndex);
6536: exception
6537: when others then
6538: ame_util.runtimeException(packageNameIn => 'ame_engine',
6539: routineNameIn => 'getItemAttValues3',
6540: exceptionNumberIn => sqlcode,
6541: exceptionStringIn => sqlerrm);
6542: raise;
6555: attributeValuesOut(outputIndex) := engAttributeValues1(i);
6556: end loop;
6557: exception
6558: when others then
6559: ame_util.runtimeException(packageNameIn => 'ame_engine',
6560: routineNameIn => 'getItemClassAttValues1',
6561: exceptionNumberIn => sqlcode,
6562: exceptionStringIn => sqlerrm);
6563: raise;
6578: attributeValuesOut(outputIndex) := engAttributeValues1(i);
6579: end loop;
6580: exception
6581: when others then
6582: ame_util.runtimeException(packageNameIn => 'ame_engine',
6583: routineNameIn => 'getItemClassAttValues2',
6584: exceptionNumberIn => sqlcode,
6585: exceptionStringIn => sqlerrm);
6586: raise;
6603: attributeValues3Out(outputIndex) := engAttributeValues3(i);
6604: end loop;
6605: exception
6606: when others then
6607: ame_util.runtimeException(packageNameIn => 'ame_engine',
6608: routineNameIn => 'getItemClassAttValues3',
6609: exceptionNumberIn => sqlcode,
6610: exceptionStringIn => sqlerrm);
6611: raise;
6630: attributeValues3Out(outputIndex) := engAttributeValues3(i);
6631: end loop;
6632: exception
6633: when others then
6634: ame_util.runtimeException(packageNameIn => 'ame_engine',
6635: routineNameIn => 'getItemClassAttValues4',
6636: exceptionNumberIn => sqlcode,
6637: exceptionStringIn => sqlerrm);
6638: raise;
6656: end if;
6657: exception
6658: when others then
6659: itemIdsOut.delete;
6660: ame_util.runtimeException(packageNameIn => 'ame_engine',
6661: routineNameIn => 'getItemClassItemIds',
6662: exceptionNumberIn => sqlcode,
6663: exceptionStringIn => sqlerrm);
6664: raise;
6669: itemClassesOut(i) := engStItemClasses(i);
6670: end loop;
6671: exception
6672: when others then
6673: ame_util.runtimeException(packageNameIn => 'ame_engine',
6674: routineNameIn => 'getItemClasses',
6675: exceptionNumberIn => sqlcode,
6676: exceptionStringIn => sqlerrm);
6677: raise;
6682: itemIdsOut(i) := engStItemIds(i);
6683: end loop;
6684: exception
6685: when others then
6686: ame_util.runtimeException(packageNameIn => 'ame_engine',
6687: routineNameIn => 'getItemIds',
6688: exceptionNumberIn => sqlcode,
6689: exceptionStringIn => sqlerrm);
6690: raise;
6695: itemIndexesOut(i) := engStItemIndexes(i);
6696: end loop;
6697: exception
6698: when others then
6699: ame_util.runtimeException(packageNameIn => 'ame_engine',
6700: routineNameIn => 'getItemIndexes',
6701: exceptionNumberIn => sqlcode,
6702: exceptionStringIn => sqlerrm);
6703: raise;
6708: itemSourcesOut(i) := engStItemSources(i);
6709: end loop;
6710: exception
6711: when others then
6712: ame_util.runtimeException(packageNameIn => 'ame_engine',
6713: routineNameIn => 'getItemSources',
6714: exceptionNumberIn => sqlcode,
6715: exceptionStringIn => sqlerrm);
6716: raise;
6729: end loop;
6730: end loop;
6731: exception
6732: when others then
6733: ame_util.runtimeException(packageNameIn => 'ame_engine',
6734: routineNameIn => 'getAllItemClasses',
6735: exceptionNumberIn => sqlcode,
6736: exceptionStringIn => sqlerrm);
6737: raise;
6742: itemIdsOut(i) := engItemIds(i);
6743: end loop;
6744: exception
6745: when others then
6746: ame_util.runtimeException(packageNameIn => 'ame_engine',
6747: routineNameIn => 'getAllItemIds',
6748: exceptionNumberIn => sqlcode,
6749: exceptionStringIn => sqlerrm);
6750: raise;
6787: tempParameter := positionIn;
6788: if (engStApproversCount = 0) then
6789:
6790: /* pre-approver */
6791: if (not ame_engine.insertionExists
6792: (orderTypeIn => ame_util.absoluteOrder
6793: ,parameterIn => tempParameter
6794: )) then
6795: availableInsertionsIndex := availableInsertionsIndex + 1;
6805: ame_util.absoluteOrderDescription || positionIn || '. ';
6806: end if;
6807:
6808: /* authority approver */
6809: if (not ame_engine.insertionExists
6810: (orderTypeIn => ame_util.absoluteOrder
6811: ,parameterIn => tempParameter
6812: )) then
6813: availableInsertionsIndex := availableInsertionsIndex + 1;
6823: ame_util.absoluteOrderDescription || positionIn || '. ';
6824: end if;
6825:
6826: /* post approver */
6827: if (not ame_engine.insertionExists
6828: (orderTypeIn => ame_util.absoluteOrder
6829: ,parameterIn => tempParameter
6830: )) then
6831: availableInsertionsIndex := availableInsertionsIndex + 1;
6845:
6846: if (positionIn < engStApproversCount + 1) then
6847:
6848: /* Attribute to the insertee the relevant properties of the approver at positionIn. */
6849: if (not ame_engine.insertionExists
6850: (orderTypeIn => ame_util.absoluteOrder
6851: ,parameterIn => tempParameter
6852: )) then
6853: availableInsertionsIndex := availableInsertionsIndex + 1;
6879: engStApprovers(positionIn).item_class <> engStApprovers(positionIn - 1).item_class
6880: ))) then
6881:
6882: /* Attribute to the insertee the relevant properties of the approver at positionIn - 1. */
6883: if (not ame_engine.insertionExists
6884: (orderTypeIn => ame_util.absoluteOrder
6885: ,parameterIn => tempParameter
6886: )) then
6887: availableInsertionsIndex := availableInsertionsIndex + 1;
6926: errorCode := -20218;
6927: errorMessage := ame_util.getMessage(applicationShortNameIn =>'PER',
6928: messageNameIn => 'AME_400837_INV_APR_FOUND',
6929: tokenNameOneIn => 'PROCESS_NAME',
6930: tokenValueOneIn => 'ame_engine.getInsertions',
6931: tokenNameTwoIn => 'NAME',
6932: tokenValueTwoIn => engStApprovers(positionIn - 1).name);
6933: raise_application_error(errorCode,errorMessage);
6934: end if;
6949: engStApprovers(positionIn - 1).group_or_chain_id ||
6950: ame_util.fieldDelimiter ||
6951: engStApprovers(positionIn - 1).occurrence;
6952:
6953: if (not ame_engine.insertionExists
6954: (orderTypeIn => ame_util.afterApprover
6955: ,parameterIn => tempParameter
6956: )) then
6957: availableInsertionsIndex := availableInsertionsIndex + 1;
6974: if (engStApprovers(positionIn).authority = ame_util.authorityApprover and
6975: engStApprovers(positionIn).api_insertion <> ame_util.apiInsertion and
6976: engStApprovers(positionIn).approver_category = ame_util.approvalApproverCategory and
6977: coaInsertionsYNIn = ame_util.booleanTrue and
6978: (not ame_engine.insertionExists
6979: (orderTypeIn => ame_util.afterApprover
6980: ,parameterIn => tempParameter
6981: ))) then /* COA */
6982: availableInsertionsIndex := availableInsertionsIndex + 1;
7019: if l_error_code = -20213 then
7020: errorMessage := ame_util.getMessage(applicationShortNameIn =>'PER',
7021: messageNameIn => 'AME_400837_INV_APR_FOUND',
7022: tokenNameOneIn => 'PROCESS_NAME',
7023: tokenValueOneIn => 'ame_engine.getInsertions',
7024: tokenNameTwoIn => 'NAME',
7025: tokenValueTwoIn => engStApprovers(positionIn).name);
7026: raise_application_error(errorCode,errorMessage);
7027: end if;
7043: engStApprovers(positionIn).group_or_chain_id ||
7044: ame_util.fieldDelimiter ||
7045: engStApprovers(positionIn).occurrence;
7046:
7047: if (not ame_engine.insertionExists
7048: (orderTypeIn => ame_util.beforeApprover
7049: ,parameterIn => tempParameter
7050: )) then
7051: availableInsertionsIndex := availableInsertionsIndex + 1;
7101: engStApprovers(positionIn).action_type_id ||
7102: ame_util.fieldDelimiter ||
7103: engStApprovers(positionIn).group_or_chain_id;
7104:
7105: if (not ame_engine.insertionExists
7106: (orderTypeIn => ame_util.firstAuthority
7107: ,parameterIn => tempParameter
7108: )) then
7109: availableInsertionsIndex := availableInsertionsIndex + 1;
7163: ame_util.headerItemClassName ||
7164: ame_util.fieldDelimiter ||
7165: engTransactionId;
7166:
7167: if (not ame_engine.insertionExists
7168: (orderTypeIn => ame_util.firstPostApprover
7169: ,parameterIn => tempParameter
7170: )) then
7171: availableInsertionsIndex := availableInsertionsIndex + 1;
7185: ame_util.fieldDelimiter ||
7186: engStApprovers(engStApproversCount).item_class ||
7187: ame_util.fieldDelimiter ||
7188: engStApprovers(engStApproversCount).item_id;
7189: if (not ame_engine.insertionExists
7190: (orderTypeIn => ame_util.firstPostApprover
7191: ,parameterIn => tempParameter
7192: )) then
7193: availableInsertionsIndex := availableInsertionsIndex + 1;
7210: ame_util.fieldDelimiter ||
7211: engStApprovers(1).item_class ||
7212: ame_util.fieldDelimiter ||
7213: engStApprovers(1).item_id;
7214: if (not ame_engine.insertionExists
7215: (orderTypeIn => ame_util.firstPostApprover
7216: ,parameterIn => tempParameter
7217: )) then
7218: availableInsertionsIndex := availableInsertionsIndex + 1;
7236: ame_util.fieldDelimiter ||
7237: engStApprovers(positionIn).item_class ||
7238: ame_util.fieldDelimiter ||
7239: engStApprovers(positionIn).item_id;
7240: if (not ame_engine.insertionExists
7241: (orderTypeIn => ame_util.firstPostApprover
7242: ,parameterIn => tempParameter
7243: )) then
7244: availableInsertionsIndex := availableInsertionsIndex + 1;
7261: ame_util.fieldDelimiter ||
7262: engStApprovers(positionIn).item_class ||
7263: ame_util.fieldDelimiter ||
7264: engStApprovers(positionIn).item_id;
7265: if (not ame_engine.insertionExists
7266: (orderTypeIn => ame_util.firstPostApprover
7267: ,parameterIn => tempParameter
7268: )) then
7269: availableInsertionsIndex := availableInsertionsIndex + 1;
7284: ame_util.fieldDelimiter ||
7285: engStApprovers(positionIn - 1).item_class ||
7286: ame_util.fieldDelimiter ||
7287: engStApprovers(positionIn - 1).item_id;
7288: if (not ame_engine.insertionExists
7289: (orderTypeIn => ame_util.firstPostApprover
7290: ,parameterIn => tempParameter
7291: )) then
7292: availableInsertionsIndex := availableInsertionsIndex + 1;
7328: ame_util.fieldDelimiter ||
7329: ame_util.headerItemClassName ||
7330: ame_util.fieldDelimiter ||
7331: engTransactionId;
7332: if (not ame_engine.insertionExists
7333: (orderTypeIn => ame_util.firstPreApprover
7334: ,parameterIn => tempParameter
7335: )) then
7336: availableInsertionsIndex := availableInsertionsIndex + 1;
7349: ame_util.fieldDelimiter ||
7350: engStApprovers(1).item_class ||
7351: ame_util.fieldDelimiter ||
7352: engStApprovers(1).item_id;
7353: if (not ame_engine.insertionExists
7354: (orderTypeIn => ame_util.firstPreApprover
7355: ,parameterIn => tempParameter
7356: )) then
7357: availableInsertionsIndex := availableInsertionsIndex + 1;
7372: ame_util.fieldDelimiter ||
7373: engStApprovers(positionIn).item_class ||
7374: ame_util.fieldDelimiter ||
7375: engStApprovers(positionIn).item_id;
7376: if (not ame_engine.insertionExists
7377: (orderTypeIn => ame_util.firstPreApprover
7378: ,parameterIn => tempParameter
7379: )) then
7380: availableInsertionsIndex := availableInsertionsIndex + 1;
7414: ame_util.fieldDelimiter ||
7415: ame_util.headerItemClassName ||
7416: ame_util.fieldDelimiter ||
7417: engTransactionId;
7418: if (not ame_engine.insertionExists
7419: (orderTypeIn => ame_util.lastPostApprover
7420: ,parameterIn => tempParameter
7421: )) then
7422: availableInsertionsIndex := availableInsertionsIndex + 1;
7435: ame_util.fieldDelimiter ||
7436: engStApprovers(engStApproversCount).item_class ||
7437: ame_util.fieldDelimiter ||
7438: engStApprovers(engStApproversCount).item_id;
7439: if (not ame_engine.insertionExists
7440: (orderTypeIn => ame_util.lastPostApprover
7441: ,parameterIn => tempParameter
7442: )) then
7443: availableInsertionsIndex := availableInsertionsIndex + 1;
7458: ame_util.fieldDelimiter ||
7459: engStApprovers(positionIn - 1).item_class ||
7460: ame_util.fieldDelimiter ||
7461: engStApprovers(positionIn - 1).item_id;
7462: if (not ame_engine.insertionExists
7463: (orderTypeIn => ame_util.lastPostApprover
7464: ,parameterIn => tempParameter
7465: )) then
7466: availableInsertionsIndex := availableInsertionsIndex + 1;
7509: ame_util.fieldDelimiter ||
7510: ame_util.headerItemClassName ||
7511: ame_util.fieldDelimiter ||
7512: engTransactionId;
7513: if (not ame_engine.insertionExists
7514: (orderTypeIn => ame_util.lastPreApprover
7515: ,parameterIn => tempParameter)) then
7516: availableInsertionsIndex := availableInsertionsIndex + 1;
7517: availableInsertionsOut(availableInsertionsIndex).item_class := ame_util.headerItemClassName;
7530: ame_util.fieldDelimiter ||
7531: engStApprovers(1).item_class ||
7532: ame_util.fieldDelimiter ||
7533: engStApprovers(1).item_id;
7534: if (not ame_engine.insertionExists
7535: (orderTypeIn => ame_util.lastPreApprover
7536: ,parameterIn => tempParameter
7537: )) then
7538: availableInsertionsIndex := availableInsertionsIndex + 1;
7556: ame_util.fieldDelimiter ||
7557: engStApprovers(positionIn).item_class ||
7558: ame_util.fieldDelimiter ||
7559: engStApprovers(positionIn).item_id;
7560: if (not ame_engine.insertionExists
7561: (orderTypeIn => ame_util.lastPreApprover
7562: ,parameterIn => tempParameter
7563: )) then
7564: availableInsertionsIndex := availableInsertionsIndex + 1;
7579: ame_util.fieldDelimiter ||
7580: engStApprovers(positionIn).item_class ||
7581: ame_util.fieldDelimiter ||
7582: engStApprovers(positionIn).item_id;
7583: if (not ame_engine.insertionExists
7584: (orderTypeIn => ame_util.lastPreApprover
7585: ,parameterIn => tempParameter
7586: )) then
7587: availableInsertionsIndex := availableInsertionsIndex + 1;
7607: (applicationShortNameIn =>'PER'
7608: ,messageNameIn => 'AME_400418_INVALID_INSERTION'
7609: );
7610: ame_util.runtimeException
7611: (packageNameIn => 'ame_engine'
7612: ,routineNameIn => 'getInsertions'
7613: ,exceptionNumberIn => errorCode
7614: ,exceptionStringIn => errorMessage
7615: );
7616: raise_application_error(errorCode,errorMessage);
7617:
7618: when others then
7619: ame_util.runtimeException
7620: (packageNameIn => 'ame_engine'
7621: ,routineNameIn => 'getInsertions'
7622: ,exceptionNumberIn => sqlcode
7623: ,exceptionStringIn => sqlerrm
7624: );
7675: errorMessage := ame_util.getMessage(applicationShortNameIn =>'PER',
7676: messageNameIn => 'AME_400685_INV_LM_RULE',
7677: tokenNameOneIn => 'RULE_KEY',
7678: tokenValueOneIn => tempRuleKey);
7679: ame_util.runtimeException(packageNameIn => 'ame_engine',
7680: routineNameIn => 'getLMCondition',
7681: exceptionNumberIn => errorCode,
7682: exceptionStringIn => errorMessage);
7683: raise_application_error(errorCode,
7682: exceptionStringIn => errorMessage);
7683: raise_application_error(errorCode,
7684: errorMessage);
7685: when others then
7686: ame_util.runtimeException(packageNameIn => 'ame_engine',
7687: routineNameIn => 'getLMCondition',
7688: exceptionNumberIn => sqlcode,
7689: exceptionStringIn => sqlerrm);
7690: raise;
7752: end if;
7753: if nextApproversType = 3 then
7754: tempProcessProductionRules := true;
7755: end if;
7756: ame_engine.lockTransaction(fndApplicationIdIn => applicationIdIn,
7757: transactionIdIn => transactionIdIn,
7758: transactionTypeIdIn => transactionTypeIn);
7759: ame_engine.updateTransactionState(isTestTransactionIn => false
7760: ,isLocalTransactionIn => false
7755: end if;
7756: ame_engine.lockTransaction(fndApplicationIdIn => applicationIdIn,
7757: transactionIdIn => transactionIdIn,
7758: transactionTypeIdIn => transactionTypeIn);
7759: ame_engine.updateTransactionState(isTestTransactionIn => false
7760: ,isLocalTransactionIn => false
7761: ,fetchConfigVarsIn => true
7762: ,fetchOldApproversIn => true
7763: ,fetchInsertionsIn => true
7776: ,transactionIdIn => transactionIdIn
7777: ,ameApplicationIdIn => null
7778: ,fndApplicationIdIn => applicationIdIn
7779: ,transactionTypeIdIn => transactionTypeIn);
7780: approvalProcessCompleteYNOut := ame_engine.getApprovalProcessCompleteYN;
7781: ameApplicationId := ame_engine.getAmeApplicationId;
7782: /* If approvalProcessCompleteYNOut is 'Y', there should be no nextApprovers. Hence
7783: return with an empty nextApproversOut table */
7784: if approvalProcessCompleteYNOut = ame_util2.completeFullyApproved or
7777: ,ameApplicationIdIn => null
7778: ,fndApplicationIdIn => applicationIdIn
7779: ,transactionTypeIdIn => transactionTypeIn);
7780: approvalProcessCompleteYNOut := ame_engine.getApprovalProcessCompleteYN;
7781: ameApplicationId := ame_engine.getAmeApplicationId;
7782: /* If approvalProcessCompleteYNOut is 'Y', there should be no nextApprovers. Hence
7783: return with an empty nextApproversOut table */
7784: if approvalProcessCompleteYNOut = ame_util2.completeFullyApproved or
7785: approvalProcessCompleteYNOut = ame_util2.completeFullyRejected or
7784: if approvalProcessCompleteYNOut = ame_util2.completeFullyApproved or
7785: approvalProcessCompleteYNOut = ame_util2.completeFullyRejected or
7786: approvalProcessCompleteYNOut = ame_util2.completePartiallyApproved or
7787: approvalProcessCompleteYNOut = ame_util2.completeNoApprovers then
7788: ame_engine.unlockTransaction(fndApplicationIdIn => applicationIdIn,
7789: transactionIdIn => transactionIdIn,
7790: transactionTypeIdIn => transactionTypeIn);
7791: return;
7792: end if;
8037: /* approvers to find */
8038: exit when nextTreeNodeIndex = ame_util.invalidTreeIndex;
8039: end loop;
8040: if copyAncillaryData and nextApproversType < 4 then
8041: ame_engine.prepareItemData(approverIndexesIn => tempApproverIndexes
8042: ,itemIndexesOut => itemIndexesOut
8043: ,itemItemClassesOut => itemClassesOut
8044: ,itemIdsOut => itemIdsOut
8045: ,itemSourcesOut => itemSourcesOut);
8057: getTransVariableNames(transVariableNamesOut => transVariableNamesOut);
8058: getTransVariableValues(transVariableValuesOut => transVariableValuesOut);
8059: end if;
8060: if flagApproversAsNotifiedIn = ame_util.booleanTrue then
8061: ameApplicationId := ame_engine.getAmeApplicationId;
8062: for i in 1 .. nextApproversOut.count loop
8063: update ame_temp_old_approver_lists
8064: set approval_status = ame_util.notifiedStatus
8065: where item_class = nextApproversOut(i).item_class
8105: if nextApproversOut(x).approval_status = ame_util.repeatedStatus then
8106: nextApproversOut(x).approval_status := null;
8107: end if;
8108: end loop;
8109: ame_engine.unlockTransaction(fndApplicationIdIn => applicationIdIn,
8110: transactionIdIn => transactionIdIn,
8111: transactionTypeIdIn => transactionTypeIn);
8112: exception
8113: when others then
8110: transactionIdIn => transactionIdIn,
8111: transactionTypeIdIn => transactionTypeIn);
8112: exception
8113: when others then
8114: ame_engine.unlockTransaction(fndApplicationIdIn => applicationIdIn,
8115: transactionIdIn => transactionIdIn,
8116: transactionTypeIdIn => transactionTypeIn);
8117: ame_util.runtimeException(packageNameIn => 'ame_engine',
8118: routineNameIn => 'getNextApprovers',
8113: when others then
8114: ame_engine.unlockTransaction(fndApplicationIdIn => applicationIdIn,
8115: transactionIdIn => transactionIdIn,
8116: transactionTypeIdIn => transactionTypeIn);
8117: ame_util.runtimeException(packageNameIn => 'ame_engine',
8118: routineNameIn => 'getNextApprovers',
8119: exceptionNumberIn => sqlcode,
8120: exceptionStringIn => sqlerrm);
8121: approvalProcessCompleteYNOut:= null;
8235: end if;
8236: end loop;
8237: exception
8238: when others then
8239: ame_util.runtimeException(packageNameIn => 'ame_engine',
8240: routineNameIn => 'prepareItemData',
8241: exceptionNumberIn => sqlcode,
8242: exceptionStringIn => sqlerrm);
8243: itemIndexesOut.delete;
8362: end loop;
8363: end loop;
8364: exception
8365: when others then
8366: ame_util.runtimeException(packageNameIn => 'ame_engine',
8367: routineNameIn => 'preparePerApproverProductions',
8368: exceptionNumberIn => sqlcode,
8369: exceptionStringIn => sqlerrm);
8370: prodIndexesOut.delete;
8452: end loop;
8453: end loop;
8454: exception
8455: when others then
8456: ame_util.runtimeException(packageNameIn => 'ame_engine',
8457: routineNameIn => 'prepareRuleData',
8458: exceptionNumberIn => sqlcode,
8459: exceptionStringIn => sqlerrm);
8460: engStRuleDescriptions.delete;
8468: productionIndexesOut(i) := engStProductionIndexes(i);
8469: end loop;
8470: exception
8471: when others then
8472: ame_util.runtimeException(packageNameIn => 'ame_engine',
8473: routineNameIn => 'getProductionIndexes',
8474: exceptionNumberIn => sqlcode,
8475: exceptionStringIn => sqlerrm);
8476: raise;
8485: repeatedAppIndexesOut(i) := engStRepeatedAppIndexes(i);
8486: end loop;
8487: exception
8488: when others then
8489: ame_util.runtimeException(packageNameIn => 'ame_engine',
8490: routineNameIn => 'getRepeatedIndexes',
8491: exceptionNumberIn => sqlcode,
8492: exceptionStringIn => sqlerrm);
8493: raise;
8498: ruleDescriptionsOut(i) := engStRuleDescriptions(i);
8499: end loop;
8500: exception
8501: when others then
8502: ame_util.runtimeException(packageNameIn => 'ame_engine',
8503: routineNameIn => 'getRuleDescriptions',
8504: exceptionNumberIn => sqlcode,
8505: exceptionStringIn => sqlerrm);
8506: raise;
8511: ruleIdsOut(i) := engStRuleIds(i);
8512: end loop;
8513: exception
8514: when others then
8515: ame_util.runtimeException(packageNameIn => 'ame_engine',
8516: routineNameIn => 'getRuleIds',
8517: exceptionNumberIn => sqlcode,
8518: exceptionStringIn => sqlerrm);
8519: raise;
8524: ruleIndexesOut(i) := engStRuleIndexes(i);
8525: end loop;
8526: exception
8527: when others then
8528: ame_util.runtimeException(packageNameIn => 'ame_engine',
8529: routineNameIn => 'getRuleIndexes',
8530: exceptionNumberIn => sqlcode,
8531: exceptionStringIn => sqlerrm);
8532: raise;
8568: return;
8569: end if;
8570: exception
8571: when others then
8572: ame_util.runtimeException(packageNameIn => 'ame_engine',
8573: routineNameIn => 'getRuntimeGroupMembers',
8574: exceptionNumberIn => sqlcode,
8575: exceptionStringIn => sqlerrm);
8576: raise;
8581: sourceTypesOut(i) := engStSourceTypes(i);
8582: end loop;
8583: exception
8584: when others then
8585: ame_util.runtimeException(packageNameIn => 'ame_engine',
8586: routineNameIn => 'getSourceTypes',
8587: exceptionNumberIn => sqlcode,
8588: exceptionStringIn => sqlerrm);
8589: raise;
8718: end loop;
8719: end loop;
8720: exception
8721: when others then
8722: ame_util.runtimeException(packageNameIn => 'ame_engine',
8723: routineNameIn => 'getTestTransApplicableRules',
8724: exceptionNumberIn => sqlcode,
8725: exceptionStringIn => sqlerrm);
8726: raise;
8826: getVariableValues(variableValuesOut => variableValuesOut);
8827: exception
8828: when others then
8829: rollback;
8830: ame_util.runtimeException(packageNameIn => 'ame_engine',
8831: routineNameIn => 'getTestTransApprovers',
8832: exceptionNumberIn => sqlcode,
8833: exceptionStringIn => sqlerrm);
8834: raise;
8845: end if;
8846: end loop;
8847: exception
8848: when others then
8849: ame_util.runtimeException(packageNameIn => 'ame_engine',
8850: routineNameIn => 'getTransVariableNames',
8851: exceptionNumberIn => sqlcode,
8852: exceptionStringIn => sqlerrm);
8853: raise;
8864: end if;
8865: end loop;
8866: exception
8867: when others then
8868: ame_util.runtimeException(packageNameIn => 'ame_engine',
8869: routineNameIn => 'getTransVariableValues',
8870: exceptionNumberIn => sqlcode,
8871: exceptionStringIn => sqlerrm);
8872: raise;
8877: variableNamesOut(i) := engStVariableNames(i);
8878: end loop;
8879: exception
8880: when others then
8881: ame_util.runtimeException(packageNameIn => 'ame_engine',
8882: routineNameIn => 'getVariableNames',
8883: exceptionNumberIn => sqlcode,
8884: exceptionStringIn => sqlerrm);
8885: raise;
8890: variableValuesOut(i) := engStVariableValues(i);
8891: end loop;
8892: exception
8893: when others then
8894: ame_util.runtimeException(packageNameIn => 'ame_engine',
8895: routineNameIn => 'getVariableValues',
8896: exceptionNumberIn => sqlcode,
8897: exceptionStringIn => sqlerrm);
8898: raise;
8931: fndApplicationIdIn => null,
8932: transactionTypeIdIn => transactionTypeIdIn);
8933: exception
8934: when others then
8935: ame_util.runtimeException(packageNameIn => 'ame_engine',
8936: routineNameIn => 'initializePlsqlContext',
8937: exceptionNumberIn => sqlcode,
8938: exceptionStringIn => sqlerrm);
8939: raise;
8948: return;
8949: end if;
8950: exception
8951: when others then
8952: ame_util.runtimeException(packageNameIn => 'ame_engine',
8953: routineNameIn => 'updateDeviationList',
8954: exceptionNumberIn => sqlcode,
8955: exceptionStringIn => sqlerrm);
8956: end updateDeviationList;
9105: l_votingRegime := ame_approval_group_pkg.getVotingRegime(
9106: approvalGroupIdIn => engStApprovers(indexIn).group_or_chain_id ,
9107: applicationIdIn => engAmeApplicationId);
9108: else
9109: l_votingRegime := ame_engine.getActionTypeVotingRegime(actionTypeIdIn => approverIn.action_type_id);
9110: end if;
9111: if engStApprovers(indexIn).approval_status in (ame_util.approvedStatus
9112: ,ame_util.approvedByRepeatedStatus
9113: ,ame_util.rejectStatus
9207: when indexException then
9208: errorCode := -20001;
9209: errorMessage := ame_util.getMessage(applicationShortNameIn =>'PER',
9210: messageNameIn => 'AME_400686_ENG_IDX_OUT_OF_BOU');
9211: ame_util.runtimeException(packageNameIn => 'ame_engine',
9212: routineNameIn => 'insertApprover',
9213: exceptionNumberIn => errorCode,
9214: exceptionStringIn => errorMessage);
9215: raise_application_error(errorCode,
9214: exceptionStringIn => errorMessage);
9215: raise_application_error(errorCode,
9216: errorMessage);
9217: when others then
9218: ame_util.runtimeException(packageNameIn => 'ame_engine',
9219: routineNameIn => 'insertApprover',
9220: exceptionNumberIn => sqlcode,
9221: exceptionStringIn => sqlerrm);
9222: raise;
9290: when indexException then
9291: errorCode := -20001;
9292: errorMessage := ame_util.getMessage(applicationShortNameIn =>'PER',
9293: messageNameIn => 'AME_400687_ENG_FIDX_OUT_OF_BOU');
9294: ame_util.runtimeException(packageNameIn => 'ame_engine',
9295: routineNameIn => 'insertApprovers',
9296: exceptionNumberIn => errorCode,
9297: exceptionStringIn => errorMessage);
9298: raise_application_error(errorCode,
9297: exceptionStringIn => errorMessage);
9298: raise_application_error(errorCode,
9299: errorMessage);
9300: when others then
9301: ame_util.runtimeException(packageNameIn => 'ame_engine',
9302: routineNameIn => 'insertApprovers',
9303: exceptionNumberIn => sqlcode,
9304: exceptionStringIn => sqlerrm);
9305: raise;
9337: approvers ame_util.approversTable2;
9338: begin
9339: tempName := nameIn;
9340: if historyTypeIn = 'BEATBYFIRSTRESPONDER' then
9341: ame_engine.getApprovers(approversOut => approvers);
9342: for i in 1 .. approvers.count loop
9343: if (approvers(i).name <> nameIn or approvers(i).occurrence <> occurrenceIn)
9344: and approvers(i).item_class = itemClassIn
9345: and approvers(i).item_id = itemIdIn
9395: end loop;
9396: return;
9397: end if;
9398: if historyTypeIn = 'CLEARFRWGRP' then
9399: ame_engine.getApprovers(approversOut => approvers);
9400: for i in 1 .. approvers.count loop
9401: if (approvers(i).name <> nameIn or approvers(i).occurrence <> occurrenceIn)
9402: and approvers(i).item_class = itemClassIn
9403: and approvers(i).item_id = itemIdIn
9627: );
9628: end if;
9629: exception
9630: when others then
9631: ame_util.runtimeException(packageNameIn => 'ame_engine',
9632: routineNameIn => 'insertIntoTransApprovalHistory',
9633: exceptionNumberIn => sqlcode,
9634: exceptionStringIn => sqlerrm);
9635:
9671: sysdate);
9672: engTransactionIsLocked := true;
9673: exception
9674: when others then
9675: ame_util.runtimeException(packageNameIn => 'ame_engine',
9676: routineNameIn => 'lockTransaction',
9677: exceptionNumberIn => sqlcode,
9678: exceptionStringIn => sqlerrm);
9679: raise;
9704: tempTransSeqId); /* Don't use engEffectiveRuleDate here. */
9705: end if;
9706: exception
9707: when others then
9708: ame_util.runtimeException(packageNameIn => 'ame_engine',
9709: routineNameIn => 'logTransaction',
9710: exceptionNumberIn => sqlcode,
9711: exceptionStringIn => sqlerrm);
9712: raise;
9732: fieldStart := fieldEnd + 1;
9733: end loop;
9734: exception
9735: when others then
9736: ame_util.runtimeException(packageNameIn => 'ame_engine',
9737: routineNameIn => 'parseFields',
9738: exceptionNumberIn => sqlcode,
9739: exceptionStringIn => sqlerrm);
9740: raise;
9754: startPosition := startPosition + valueLength + 1;
9755: end loop;
9756: exception
9757: when others then
9758: ame_util.runtimeException(packageNameIn => 'ame_engine',
9759: routineNameIn => 'parseForwardingBehaviors',
9760: exceptionNumberIn => sqlcode,
9761: exceptionStringIn => sqlerrm);
9762: raise;
9794: startPosition := endPosition + 2;
9795: end loop;
9796: exception
9797: when others then
9798: ame_util.runtimeException(packageNameIn => 'ame_engine',
9799: routineNameIn => 'parsePriorityModes',
9800: exceptionNumberIn => sqlcode,
9801: exceptionStringIn => sqlerrm);
9802: raise;
9904: end if;
9905: end loop;
9906:
9907: if itemRejected then
9908: stoppingRule := ame_engine.getHeaderAttValue2
9909: (attributeNameIn => ame_util.rejectionResponseAttribute);
9910: if stoppingRule is null or stoppingRule not in (ame_util.stopAllItems,ame_util.continueOtherSubItems,
9911: ame_util.continueAllOtherItems) then
9912: stoppingRule := ame_util.stopAllItems;
9971: engStApprovalProcessCompleteYN := ame_util2.notCompleted;
9972: end if;
9973: exception
9974: when others then
9975: ame_util.runtimeException(packageNameIn => 'ame_engine',
9976: routineNameIn => 'populateEngStVariables',
9977: exceptionNumberIn => sqlcode,
9978: exceptionStringIn => sqlerrm);
9979: raise;
10034: errorCode := -20219;
10035: errorMessage := ame_util.getMessage(applicationShortNameIn =>'PER',
10036: messageNameIn => 'AME_400837_INV_APR_FOUND',
10037: tokenNameOneIn => 'PROCESS_NAME',
10038: tokenValueOneIn => 'ame_engine.processAdHocInsertions',
10039: tokenNameTwoIn => 'NAME',
10040: tokenValueTwoIn => engInsertedApproverList(i).name);
10041: raise_application_error(errorCode,errorMessage);
10042: raise;
10112: end if;
10113: if fnd_log.g_current_runtime_level <= fnd_log.level_statement then
10114: fnd_log.string
10115: (fnd_log.level_statement
10116: ,'ame_engine.processAdhocInsertions'
10117: ,'Adhoc Insertion approver(absolute order) ::: ' || engInsertedApproverList(i).name
10118: );
10119: end if;
10120: insertApprover(indexIn => tempIndex,
10176: engStApprovers(tempIndex).group_or_chain_order_number;
10177: if fnd_log.g_current_runtime_level <= fnd_log.level_statement then
10178: fnd_log.string
10179: (fnd_log.level_statement
10180: ,'ame_engine.processAdhocInsertions'
10181: ,'Adhoc Insertion approver(after/before approver) ::: ' || engInsertedApproverList(i).name
10182: );
10183: end if;
10184: insertApprover(indexIn => tempIndex2,
10526: engInsertedApproverList(i).action_type_id := -1;
10527: if fnd_log.g_current_runtime_level <= fnd_log.level_statement then
10528: fnd_log.string
10529: (fnd_log.level_statement
10530: ,'ame_engine.processAdhocInsertions'
10531: ,'Adhoc Insertion approver(first pre/first post approver) ::: ' || engInsertedApproverList(i).name
10532: );
10533: end if;
10534: insertApprover(indexIn => tempIndex,
10544: engInsertedApproverList(i).action_type_id := -2;
10545: if fnd_log.g_current_runtime_level <= fnd_log.level_statement then
10546: fnd_log.string
10547: (fnd_log.level_statement
10548: ,'ame_engine.processAdhocInsertions'
10549: ,'Adhoc Insertion approver(last pre/last post approver) ::: ' || engInsertedApproverList(i).name
10550: );
10551: end if;
10552: insertApprover(indexIn => tempIndex,
10583: engStApprovers(j + 1).item_class <> parameterFields(3))) then
10584: if fnd_log.g_current_runtime_level <= fnd_log.level_statement then
10585: fnd_log.string
10586: (fnd_log.level_statement
10587: ,'ame_engine.processAdhocInsertions'
10588: ,'Adhoc Insertion approver(displaced) ::: ' || engInsertedApproverList(displacedInserteeIndexes(i)).name
10589: );
10590: end if;
10591: insertApprover(indexIn => j + 1,
10602: if(tempBoolean) then
10603: if fnd_log.g_current_runtime_level <= fnd_log.level_statement then
10604: fnd_log.string
10605: (fnd_log.level_statement
10606: ,'ame_engine.processAdhocInsertions'
10607: ,'Adhoc Insertion approver(displaced) ::: ' || engInsertedApproverList(displacedInserteeIndexes(i)).name
10608: );
10609: end if;
10610: insertApprover(indexIn => engStApproversCount + 1,
10626: end if;
10627: end loop;
10628: exception
10629: when others then
10630: ame_util.runtimeException(packageNameIn => 'ame_engine',
10631: routineNameIn => 'processAdHocInsertions',
10632: exceptionNumberIn => sqlcode,
10633: exceptionStringIn => sqlerrm);
10634: raise;
10680: engStProductionsTable(tempIndex).item_id := getHandlerItemId;
10681: if fnd_log.g_current_runtime_level <= fnd_log.level_statement then
10682: fnd_log.string
10683: (fnd_log.level_statement
10684: ,'ame_engine.processActionType'
10685: ,'Transaction Production ::: ' || engStProductionsTable(tempIndex).variable_name || '/' || engStProductionsTable(tempIndex).variable_value
10686: );
10687: end if;
10688: end loop;
10698: */
10699: if fnd_log.g_current_runtime_level <= fnd_log.level_statement then
10700: fnd_log.string
10701: (fnd_log.level_statement
10702: ,'ame_engine.processActionType'
10703: ,'Processing Action Type ::: ' || engAppActionTypeIds(engAppHandlerFirstIndex)
10704: );
10705: end if;
10706: execute immediate
10710: end if;
10711: if fnd_log.g_current_runtime_level <= fnd_log.level_statement then
10712: fnd_log.string
10713: (fnd_log.level_statement
10714: ,'ame_engine.processActionType'
10715: ,'Completed processing the action Type ::: ' || engAppActionTypeIds(engAppHandlerFirstIndex)
10716: );
10717: end if;
10718: exception
10716: );
10717: end if;
10718: exception
10719: when others then
10720: ame_util.runtimeException(packageNameIn => 'ame_engine',
10721: routineNameIn => 'processActionType',
10722: exceptionNumberIn => sqlcode,
10723: exceptionStringIn => sqlerrm);
10724: raise;
10749: engDeviationResultList(approverIndexIn).effectiveDate := engSuppressionDateList(suppressApproverIndex);
10750: engDeviationResultList(approverIndexIn).reason := engSupperssionReasonList(suppressApproverIndex);
10751: exception
10752: when others then
10753: ame_util.runtimeException(packageNameIn => 'ame_engine',
10754: routineNameIn => 'processSuppressDeviation',
10755: exceptionNumberIn => sqlcode,
10756: exceptionStringIn => sqlerrm);
10757: end processSuppressDeviation;
10770: processSuppressDeviation(j,i);
10771: if fnd_log.g_current_runtime_level <= fnd_log.level_statement then
10772: fnd_log.string
10773: (fnd_log.level_statement
10774: ,'ame_engine.processSuppressions'
10775: ,'Suppressed approver ::: ' || engStApprovers(j).name
10776: );
10777: end if;
10778: end if;
10779: end loop;
10780: end loop;
10781: exception
10782: when others then
10783: ame_util.runtimeException(packageNameIn => 'ame_engine',
10784: routineNameIn => 'processSuppressions',
10785: exceptionNumberIn => sqlcode,
10786: exceptionStringIn => sqlerrm);
10787: raise;
10958: compactParametersIn => true);
10959: end if;
10960: exception
10961: when others then
10962: ame_util.runtimeException(packageNameIn => 'ame_engine',
10963: routineNameIn => 'processExceptions',
10964: exceptionNumberIn => sqlcode,
10965: exceptionStringIn => sqlerrm);
10966: raise;
11084: engStApprovers(j).approval_status := ame_util.repeatedStatus;
11085: if fnd_log.g_current_runtime_level <= fnd_log.level_statement then
11086: fnd_log.string
11087: (fnd_log.level_statement
11088: ,'ame_engine.processRepeatedApprovers'
11089: ,'Repeated Approver ::: ' || engStApprovers(j).name
11090: );
11091: end if;
11092: end if;
11168: end if;
11169: end loop;
11170: exception
11171: when others then
11172: ame_util.runtimeException(packageNameIn => 'ame_engine',
11173: routineNameIn => 'processRepeatedApprovers',
11174: exceptionNumberIn => sqlcode,
11175: exceptionStringIn => sqlerrm);
11176: raise;
11237: if processOnlyProductionsIn then
11238: if fnd_log.g_current_runtime_level <= fnd_log.level_statement then
11239: fnd_log.string
11240: (fnd_log.level_statement
11241: ,'ame_engine.processRules'
11242: ,'Processing only production rules'
11243: );
11244: end if;
11245: ruleTypeUpperLimit := 1;
11246: else
11247: if fnd_log.g_current_runtime_level <= fnd_log.level_statement then
11248: fnd_log.string
11249: (fnd_log.level_statement
11250: ,'ame_engine.processRules'
11251: ,'Processing all rules'
11252: );
11253: end if;
11254: ruleTypeUpperLimit := 6;
11309: if fnd_log.g_current_runtime_level <= fnd_log.level_statement then
11310: if engStApprovers.count = 0 then
11311: fnd_log.string
11312: (fnd_log.level_statement
11313: ,'ame_engine.processRules'
11314: ,'**************** No Approvers ******************'
11315: );
11316: else
11317: for i in 1 .. engStApprovers.count loop
11316: else
11317: for i in 1 .. engStApprovers.count loop
11318: fnd_log.string
11319: (fnd_log.level_statement
11320: ,'ame_engine.processRules'
11321: ,'Approver ::: ' || engStApprovers(i).name
11322: );
11323: end loop;
11324: end if;
11324: end if;
11325: end if;
11326: exception
11327: when others then
11328: ame_util.runtimeException(packageNameIn => 'ame_engine',
11329: routineNameIn => 'processRules',
11330: exceptionNumberIn => sqlcode,
11331: exceptionStringIn => sqlerrm);
11332: raise;
11481: compactParametersIn => false);
11482: end if;
11483: exception
11484: when others then
11485: ame_util.runtimeException(packageNameIn => 'ame_engine',
11486: routineNameIn => 'processRelativePriorities',
11487: exceptionNumberIn => sqlcode,
11488: exceptionStringIn => sqlerrm);
11489: raise;
11541: /* tempSurrogateApprover.approver_order_number also gets set later. */
11542: if fnd_log.g_current_runtime_level <= fnd_log.level_statement then
11543: fnd_log.string
11544: (fnd_log.level_statement
11545: ,'ame_engine.processUnresponsiveApprovers'
11546: ,'Unresponsive approver ::: ' || engStApprovers(tempIndex).name || ' Surrogate ::: ' || tempSurrogateApprover.name
11547: );
11548: end if;
11549: engTempReason := ame_approver_deviation_pkg.timeoutReason;
11559: tempIndex := tempIndex + 1;
11560: end loop;
11561: exception
11562: when others then
11563: ame_util.runtimeException(packageNameIn => 'ame_engine',
11564: routineNameIn => 'processUnresponsiveApprovers',
11565: exceptionNumberIn => sqlcode,
11566: exceptionStringIn => sqlerrm);
11567: raise;
11828: when badLocalTransException then
11829: errorCode := -20001;
11830: errorMessage := ame_util.getMessage(applicationShortNameIn =>'PER',
11831: messageNameIn => 'AME_400688_ENG_TESTTX_NONLOCAL');
11832: ame_util.runtimeException(packageNameIn => 'ame_engine',
11833: routineNameIn => 'setContext',
11834: exceptionNumberIn => errorCode,
11835: exceptionStringIn => errorMessage);
11836: raise_application_error(errorCode,
11838: when nullValuesException then
11839: errorCode := -20001;
11840: errorMessage := ame_util.getMessage(applicationShortNameIn =>'PER',
11841: messageNameIn => 'AME_400129_ENG_APPLID_NULL');
11842: ame_util.runtimeException(packageNameIn => 'ame_engine',
11843: routineNameIn => 'setContext',
11844: exceptionNumberIn => errorCode,
11845: exceptionStringIn => errorMessage);
11846: raise_application_error(errorCode,
11845: exceptionStringIn => errorMessage);
11846: raise_application_error(errorCode,
11847: errorMessage);
11848: when others then
11849: ame_util.runtimeException(packageNameIn => 'ame_engine',
11850: routineNameIn => 'setContext',
11851: exceptionNumberIn => sqlcode,
11852: exceptionStringIn => sqlerrm);
11853: raise;
11888: when argumentLengthException then
11889: errorCode := -20001;
11890: errorMessage := ame_util.getMessage(applicationShortNameIn =>'PER',
11891: messageNameIn => 'AME_400130_ENG_HDLR_PAR_LNG');
11892: ame_util.runtimeException(packageNameIn => 'ame_engine',
11893: routineNameIn => 'setHandlerState',
11894: exceptionNumberIn => errorCode,
11895: exceptionStringIn => errorMessage);
11896: raise_application_error(errorCode,
11895: exceptionStringIn => errorMessage);
11896: raise_application_error(errorCode,
11897: errorMessage);
11898: when others then
11899: ame_util.runtimeException(packageNameIn => 'ame_engine',
11900: routineNameIn => 'setHandlerState',
11901: exceptionNumberIn => sqlcode,
11902: exceptionStringIn => sqlerrm);
11903: raise;
11927: end loop;
11928: end if;
11929: exception
11930: when others then
11931: ame_util.runtimeException(packageNameIn => 'ame_engine',
11932: routineNameIn => 'setInsertedApprovalStatus',
11933: exceptionNumberIn => sqlcode,
11934: exceptionStringIn => sqlerrm);
11935: raise;
12018: end loop;
12019: end loop;
12020: exception
12021: when others then
12022: ame_util.runtimeException(packageNameIn => 'ame_engine',
12023: routineNameIn => 'sortApplicableRules',
12024: exceptionNumberIn => sqlcode,
12025: exceptionStringIn => sqlerrm);
12026: raise;
12050: errorCode := -20220;
12051: errorMessage := ame_util.getMessage(applicationShortNameIn =>'PER',
12052: messageNameIn => 'AME_400837_INV_APR_FOUND',
12053: tokenNameOneIn => 'PROCESS_NAME',
12054: tokenValueOneIn => 'ame_engine.substituteApprover',
12055: tokenNameTwoIn => 'NAME',
12056: tokenValueTwoIn => nameIn);
12057: raise_application_error(errorCode,errorMessage);
12058: end if;
12102: end if;
12103: end loop;
12104: exception
12105: when others then
12106: ame_util.runtimeException(packageNameIn => 'ame_engine',
12107: routineNameIn => 'substituteApprover',
12108: exceptionNumberIn => sqlcode,
12109: exceptionStringIn => sqlerrm);
12110: raise;
12200: /* Delete the last truncateCount places. */
12201: engStApprovers.delete(engStApproversCount - truncateCount + 1, engStApproversCount);
12202: exception
12203: when others then
12204: ame_util.runtimeException(packageNameIn => 'ame_engine',
12205: routineNameIn => 'truncateChain',
12206: exceptionNumberIn => sqlcode,
12207: exceptionStringIn => sqlerrm);
12208: raise;
12221: end if;
12222: engTransactionIsLocked := false;
12223: exception
12224: when others then
12225: ame_util.runtimeException(packageNameIn => 'ame_engine',
12226: routineNameIn => 'unlockTransaction',
12227: exceptionNumberIn => sqlcode,
12228: exceptionStringIn => sqlerrm);
12229: raise;
12276: transactionTypeIdIn => transactionTypeIdIn);
12277: if fnd_log.g_current_runtime_level <= fnd_log.level_statement then
12278: fnd_log.string
12279: (fnd_log.level_statement
12280: ,'ame_engine.updateTransactionState'
12281: ,'AME Application Id ::: ' || engAmeApplicationId
12282: );
12283: fnd_log.string
12284: (fnd_log.level_statement
12281: ,'AME Application Id ::: ' || engAmeApplicationId
12282: );
12283: fnd_log.string
12284: (fnd_log.level_statement
12285: ,'ame_engine.updateTransactionState'
12286: ,'AME Transaction Id ::: ' || engTransactionId
12287: );
12288: end if;
12289: /* Added from version 115.217 to log a transaction (backward compatiblity)*/
12313: end if;
12314: if fnd_log.g_current_runtime_level <= fnd_log.level_statement then
12315: fnd_log.string
12316: (fnd_log.level_statement
12317: ,'ame_engine.updateTransactionState'
12318: ,'Approver count after processRules ::: ' || engStApprovers.count
12319: );
12320: end if;
12321: if(updateCurrentApproverListIn or
12323: processAdHocInsertions;
12324: if fnd_log.g_current_runtime_level <= fnd_log.level_statement then
12325: fnd_log.string
12326: (fnd_log.level_statement
12327: ,'ame_engine.updateTransactionState'
12328: ,'Approver count after processAdHocInsertions ::: ' || engStApprovers.count
12329: );
12330: end if;
12331: processUnresponsiveApprovers;
12331: processUnresponsiveApprovers;
12332: if fnd_log.g_current_runtime_level <= fnd_log.level_statement then
12333: fnd_log.string
12334: (fnd_log.level_statement
12335: ,'ame_engine.updateTransactionState'
12336: ,'Approver count after processUnresponsiveApprovers ::: ' || engStApprovers.count
12337: );
12338: end if;
12339: if engRepeatSubstitutions then
12340: repeatSubstitutions;
12341: if fnd_log.g_current_runtime_level <= fnd_log.level_statement then
12342: fnd_log.string
12343: (fnd_log.level_statement
12344: ,'ame_engine.updateTransactionState'
12345: ,'Approver count after repeatSubstitutions ::: ' || engStApprovers.count
12346: );
12347: end if;
12348: end if;
12354: processSuppressions;
12355: if fnd_log.g_current_runtime_level <= fnd_log.level_statement then
12356: fnd_log.string
12357: (fnd_log.level_statement
12358: ,'ame_engine.updateTransactionState'
12359: ,'Approver count after processSuppressions ::: ' || engStApprovers.count
12360: );
12361: end if;
12362: /*
12366: processRepeatedApprovers;
12367: if fnd_log.g_current_runtime_level <= fnd_log.level_statement then
12368: fnd_log.string
12369: (fnd_log.level_statement
12370: ,'ame_engine.updateTransactionState'
12371: ,'Approver count after processRepeatedApprovers ::: ' || engStApprovers.count
12372: );
12373: end if;
12374: /*
12391: if fnd_log.g_current_runtime_level <= fnd_log.level_statement then
12392: if engStApprovers.count = 0 then
12393: fnd_log.string
12394: (fnd_log.level_statement
12395: ,'ame_engine.updateTransactionState'
12396: ,'**************** No Approvers ******************'
12397: );
12398: else
12399: for i in 1 .. engStApprovers.count loop
12398: else
12399: for i in 1 .. engStApprovers.count loop
12400: fnd_log.string
12401: (fnd_log.level_statement
12402: ,'ame_engine.updateTransactionState'
12403: ,'Approver ::: ' || engStApprovers(i).name || ' Order Number ::: ' || engStApprovers(i).approver_order_number
12404: );
12405: end loop;
12406: end if;
12413: when configVarException then
12414: errorCode := -20001;
12415: errorMessage := ame_util.getMessage(applicationShortNameIn =>'PER',
12416: messageNameIn => 'AME_400691_INV_PARAM_ENG_UPDTX');
12417: ame_util.runtimeException(packageNameIn => 'ame_engine',
12418: routineNameIn => 'updateTransactionState',
12419: exceptionNumberIn => errorCode,
12420: exceptionStringIn => errorMessage);
12421: raise_application_error(errorCode,
12420: exceptionStringIn => errorMessage);
12421: raise_application_error(errorCode,
12422: errorMessage);
12423: when others then
12424: ame_util.runtimeException(packageNameIn => 'ame_engine',
12425: routineNameIn => 'updateTransactionState',
12426: exceptionNumberIn => sqlcode,
12427: exceptionStringIn => sqlerrm);
12428: raise;
12501: tempCategories(i),
12502: tempStatuses(i));
12503: exception
12504: when others then
12505: ame_util.runtimeException(packageNameIn => 'ame_engine',
12506: routineNameIn => 'updateOldApproverList',
12507: exceptionNumberIn => sqlcode,
12508: exceptionStringIn => sqlerrm);
12509: raise;
12515: begin
12516: null;
12517: exception
12518: when others then
12519: ame_util.runtimeException(packageNameIn => 'ame_engine',
12520: routineNameIn => 'testEngine',
12521: exceptionNumberIn => sqlcode,
12522: exceptionStringIn => sqlerrm);
12523: raise;
12571: l_actionTypeId Number;
12572: l_frw_index number;
12573: begin
12574: /* Lock the transaction. */
12575: ame_engine.lockTransaction(fndApplicationIdIn => applicationIdIn,
12576: transactionIdIn => transactionIdIn,
12577: transactionTypeIdIn => transactionTypeIn);
12578: /* Clear the exception log when required. */
12579: if(approverIn.approval_status = ame_util.clearExceptionsStatus) then
12580: delete from ame_exceptions_log
12581: where
12582: transaction_id = transactionIdIn and
12583: application_id = ameApplicationId;
12584: ame_engine.unlockTransaction(fndApplicationIdIn => applicationIdIn,
12585: transactionIdIn => transactionIdIn,
12586: transactionTypeIdIn => transactionTypeIn);
12587: return;
12588: end if;
12586: transactionTypeIdIn => transactionTypeIn);
12587: return;
12588: end if;
12589: /* Locate approverIn in the current approver list, if possible. */
12590: ame_engine.updateTransactionState(isTestTransactionIn => false,
12591: isLocalTransactionIn => false,
12592: fetchConfigVarsIn => true,
12593: fetchOldApproversIn => true,
12594: fetchInsertionsIn => true,
12607: transactionIdIn => transactionIdIn,
12608: ameApplicationIdIn => null,
12609: fndApplicationIdIn => applicationIdIn,
12610: transactionTypeIdIn => transactionTypeIn);
12611: ame_engine.getApprovers(approversOut => currentApprovers);
12612: ame_engine.getRepeatedIndexes(repeatedIndexesOut => repeatedIndexes
12613: ,repeatedAppIndexesOut => repeatedAppIndexes);
12614: ameApplicationId := ame_engine.getAmeApplicationId;
12615: approverInIndex := null;
12608: ameApplicationIdIn => null,
12609: fndApplicationIdIn => applicationIdIn,
12610: transactionTypeIdIn => transactionTypeIn);
12611: ame_engine.getApprovers(approversOut => currentApprovers);
12612: ame_engine.getRepeatedIndexes(repeatedIndexesOut => repeatedIndexes
12613: ,repeatedAppIndexesOut => repeatedAppIndexes);
12614: ameApplicationId := ame_engine.getAmeApplicationId;
12615: approverInIndex := null;
12616: if(approverIn.occurrence is null or
12610: transactionTypeIdIn => transactionTypeIn);
12611: ame_engine.getApprovers(approversOut => currentApprovers);
12612: ame_engine.getRepeatedIndexes(repeatedIndexesOut => repeatedIndexes
12613: ,repeatedAppIndexesOut => repeatedAppIndexes);
12614: ameApplicationId := ame_engine.getAmeApplicationId;
12615: approverInIndex := null;
12616: if(approverIn.occurrence is null or
12617: approverIn.group_or_chain_id is null or
12618: approverIn.action_type_id is null or
12668: end loop;
12669: end if;
12670: else /* complete match */
12671: for i in 1 .. currentApprovers.count loop
12672: if(ame_engine.approversMatch(approverRecord1In => currentApprovers(i),
12673: approverRecord2In => approverIn)) then
12674: approverInIndex := i;
12675: exit;
12676: end if;
12760: errorCode := -20221;
12761: errorMessage := ame_util.getMessage(applicationShortNameIn =>'PER',
12762: messageNameIn => 'AME_400837_INV_APR_FOUND',
12763: tokenNameOneIn => 'PROCESS_NAME',
12764: tokenValueOneIn => 'ame_engine.updateApprovalStatus',
12765: tokenNameTwoIn => 'NAME',
12766: tokenValueTwoIn => forwardee.name);
12767: raise_application_error(errorCode,errorMessage);
12768: end if;
12860: Pass localErrorIn => true in this case, because we're just logging a warning
12861: to the AME exception log, and we don't want the warning to appear in the
12862: Workflow context stack.
12863: */
12864: ame_util.runtimeException(packageNameIn => 'ame_engine',
12865: routineNameIn => 'updateApprovalStatus',
12866: exceptionNumberIn => errorCode,
12867: exceptionStringIn => errorMessage);
12868: return;
13050: ,approvalStatusIn => tempStatus);
13051: l_frw_index := repeatedAppIndexes(z);
13052: l_actionTypeId := currentApprovers(l_frw_index).action_type_id;
13053: l_votingRegime := null;
13054: l_votingRegime := ame_engine.getActionTypeVotingRegime(l_actionTypeId);
13055: if l_votingRegime is null then
13056: l_votingRegime := ame_approval_group_pkg.getVotingRegime(
13057: approvalGroupIdIn => currentApprovers(l_frw_index).group_or_chain_id ,
13058: applicationIdIn => ameApplicationId);
13152: approvalGroupIdIn => approver.group_or_chain_id ,
13153: applicationIdIn => ameApplicationId);
13154: -- in approver.group_or_chain_id
13155: else
13156: votingRegime := ame_engine.getActionTypeVotingRegime(actionTypeIdIn => approver.action_type_id);
13157: end if;
13158: if(votingRegime = ame_util.firstApproverVoting) then
13159: if approver.approval_status in (ame_util.approvedStatus, ame_util.rejectStatus ) then
13160: /*
13272: errorCode := -20221;
13273: errorMessage := ame_util.getMessage(applicationShortNameIn =>'PER',
13274: messageNameIn => 'AME_400837_INV_APR_FOUND',
13275: tokenNameOneIn => 'PROCESS_NAME',
13276: tokenValueOneIn => 'ame_engine.updateApprovalStatus',
13277: tokenNameTwoIn => 'NAME',
13278: tokenValueTwoIn => forwardee.name);
13279: raise_application_error(errorCode,errorMessage);
13280: end if;
13280: end if;
13281: raise;
13282: end;
13283: end if;
13284: tempInsertionOrder := ame_engine.getNextInsertionOrder;
13285: tempParameter := approver.name ||
13286: ame_util.fieldDelimiter ||
13287: approver.item_class ||
13288: ame_util.fieldDelimiter ||
13366: if(forwardeeType is null) then /* Handle normal forwarding cases. */
13367: if(approver.orig_system <> forwardee.orig_system) then
13368: forwarderType := ame_util.adHocForwarder;
13369: end if;
13370: tempInsertionOrder := ame_engine.getNextInsertionOrder;
13371: tempParameter := approver.name ||
13372: ame_util.fieldDelimiter ||
13373: approver.item_class ||
13374: ame_util.fieldDelimiter ||
13416: action_type_id and group_or_chain_id as approver. The insertees' source
13417: should always be ame_util.specialForwardInsertion. The insertions' order
13418: types should always be ame_util.afterApprover.
13419: */
13420: forwardingBehavior := ame_engine.getForwardingBehavior(forwarderTypeIn => forwarderType,
13421: forwardeeTypeIn => forwardeeType,
13422: approvalStatusIn => approver.approval_status);
13423: if(forwardingBehavior in (ame_util.repeatForwarder,
13424: ame_util.skipForwarder,
13443: /* Handle the special forwarding cases. */
13444: if(forwardingBehavior in (ame_util.forwardeeOnly,
13445: ame_util.forwarderAndForwardee)) then
13446: /* Insert forwardee as ad-hoc or COA, according to whether approverIn is ad-hoc or COA. */
13447: tempInsertionOrder := ame_engine.getNextInsertionOrder;
13448: tempParameter := approver.name ||
13449: ame_util.fieldDelimiter ||
13450: approver.item_class ||
13451: ame_util.fieldDelimiter ||
13489: ame_util.booleanTrue,
13490: sysdate,
13491: ame_approver_deviation_pkg.forwardReason);
13492: if(forwardingBehavior = ame_util.forwarderAndForwardee) then /* Insert the forwarder. */
13493: tempInsertionOrder := ame_engine.getNextInsertionOrder;
13494: tempParameter := forwardee.name ||
13495: ame_util.fieldDelimiter ||
13496: forwardee.item_class ||
13497: ame_util.fieldDelimiter ||
13545: approverIn and stop. In the case of ame_util.skipForwarder, we then add
13546: approverIn's superior and stop. The insertees are all COA approvers.
13547: */
13548: /* Insert the forwardee. */
13549: tempInsertionOrder := ame_engine.getNextInsertionOrder;
13550: tempParameter := approver.name ||
13551: ame_util.fieldDelimiter ||
13552: approver.item_class ||
13553: ame_util.fieldDelimiter ||
13623: exit;
13624: end if;
13625: end loop;
13626: /* Prepare and do the insertion. */
13627: tempInsertionOrder := ame_engine.getNextInsertionOrder;
13628: tempParameter := insertedApprover.name ||
13629: ame_util.fieldDelimiter ||
13630: insertedApprover.item_class ||
13631: ame_util.fieldDelimiter ||
13694: exit;
13695: end if;
13696: end loop;
13697: end if;
13698: tempInsertionOrder := ame_engine.getNextInsertionOrder;
13699: tempParameter := currentApprovers(prevApproverIndex).name ||
13700: ame_util.fieldDelimiter ||
13701: approver.item_class ||
13702: ame_util.fieldDelimiter ||
13743: /* else forwardingBehavior = ame_util.ignoreForwarding */
13744: end if;
13745: end if;
13746: /* Cycle the engine to write the forwardees out to the old-approvers table. */
13747: ame_engine.updateTransactionState(isTestTransactionIn => false,
13748: isLocalTransactionIn => false,
13749: fetchConfigVarsIn => true,
13750: fetchOldApproversIn => true,
13751: fetchInsertionsIn => true,
13764: ameApplicationIdIn => null,
13765: fndApplicationIdIn => applicationIdIn,
13766: transactionTypeIdIn => transactionTypeIn);
13767: end if;
13768: ame_engine.unlockTransaction(fndApplicationIdIn => applicationIdIn,
13769: transactionIdIn => transactionIdIn,
13770: transactionTypeIdIn => transactionTypeIn);
13771: exception
13772: when badForwardeeException then
13769: transactionIdIn => transactionIdIn,
13770: transactionTypeIdIn => transactionTypeIn);
13771: exception
13772: when badForwardeeException then
13773: ame_engine.unlockTransaction(fndApplicationIdIn => applicationIdIn,
13774: transactionIdIn => transactionIdIn,
13775: transactionTypeIdIn => transactionTypeIn);
13776: errorCode := -20101;
13777: if transactionTypeIn is not null then
13786: messageNameIn => 'AME_400066_API_FOR_NOT_VALID2',
13787: tokenNameOneIn => 'TRANSACTION_ID',
13788: tokenValueOneIn => transactionIdIn);
13789: end if;
13790: ame_util.runtimeException(packageNameIn => 'ame_engine',
13791: routineNameIn => 'updateApprovalStatus',
13792: exceptionNumberIn => errorCode,
13793: exceptionStringIn => errorMessage);
13794: raise_application_error(errorCode,
13793: exceptionStringIn => errorMessage);
13794: raise_application_error(errorCode,
13795: errorMessage);
13796: when apiInsertionException then
13797: ame_engine.unlockTransaction(fndApplicationIdIn => applicationIdIn,
13798: transactionIdIn => transactionIdIn,
13799: transactionTypeIdIn => transactionTypeIn);
13800: errorCode := -20308;
13801: errorMessage :=
13800: errorCode := -20308;
13801: errorMessage :=
13802: ame_util.getMessage(applicationShortNameIn => 'PER',
13803: messageNameIn => 'AME_400246_API_FWD_SAME_VALUE');
13804: ame_util.runtimeException(packageNameIn => 'ame_engine',
13805: routineNameIn => 'updateApprovalStatus',
13806: exceptionNumberIn => errorCode,
13807: exceptionStringIn => errorMessage);
13808: raise_application_error(errorCode,
13807: exceptionStringIn => errorMessage);
13808: raise_application_error(errorCode,
13809: errorMessage);
13810: when badStatusException then
13811: ame_engine.unlockTransaction(fndApplicationIdIn => applicationIdIn,
13812: transactionIdIn => transactionIdIn,
13813: transactionTypeIdIn => transactionTypeIn);
13814: errorCode := -20001;
13815: if transactionTypeIn is not null then
13844: tokenValueFiveIn => ame_util.forwardStatus,
13845: tokenNameSixIn => 'REJECT_STATUS',
13846: tokenValueSixIn => ame_util.rejectStatus);
13847: end if;
13848: ame_util.runtimeException(packageNameIn => 'ame_engine',
13849: routineNameIn => 'updateApprovalStatus',
13850: exceptionNumberIn => errorCode,
13851: exceptionStringIn => errorMessage);
13852: raise_application_error(errorCode,
13851: exceptionStringIn => errorMessage);
13852: raise_application_error(errorCode,
13853: errorMessage);
13854: when others then
13855: ame_engine.unlockTransaction(fndApplicationIdIn => applicationIdIn,
13856: transactionIdIn => transactionIdIn,
13857: transactionTypeIdIn => transactionTypeIn);
13858: ame_util.runtimeException(packageNameIn => 'ame_engine',
13859: routineNameIn => 'updateApprovalStatus',
13854: when others then
13855: ame_engine.unlockTransaction(fndApplicationIdIn => applicationIdIn,
13856: transactionIdIn => transactionIdIn,
13857: transactionTypeIdIn => transactionTypeIn);
13858: ame_util.runtimeException(packageNameIn => 'ame_engine',
13859: routineNameIn => 'updateApprovalStatus',
13860: exceptionNumberIn => sqlcode,
13861: exceptionStringIn => sqlerrm);
13862: raise;
13887: begin
13888: engTempReason := reasonIn;
13889: engTempDate := dateIn;
13890: end setDeviationReasonDate;
13891: end ame_engine;