APPS.IBY_DISBURSE_UI_API_PUB_PKG dependencies on FND_API

Line 141: | FND_API.G_RET_STS_SUCCESS indicates that a

137: | p_request_date
138: |
139: | OUT
140: | x_return_status - Result of the API call:
141: | FND_API.G_RET_STS_SUCCESS indicates that a
142: | callout was invoked successfully.
143: | In this case the caller must COMMIT
144: | the status change.
145: |

Line 146: | FND_API.G_RET_STS_UNEXP_ERROR (or other) indicates

142: | callout was invoked successfully.
143: | In this case the caller must COMMIT
144: | the status change.
145: |
146: | FND_API.G_RET_STS_UNEXP_ERROR (or other) indicates
147: | that API did not complete successfully.
148: | In this case, the caller must issue a
149: | ROLLBACK to undo all status changes.
150: | x_msg_count

Line 190: x_return_status := FND_API.G_RET_STS_SUCCESS;

186:
187: WHERE
188: PAYMENT_ID = p_payment_id;
189:
190: x_return_status := FND_API.G_RET_STS_SUCCESS;
191: IF ( G_LEVEL_STATEMENT >= G_CURRENT_RUNTIME_LEVEL) THEN
192: print_debuginfo(l_module_name, 'EXIT');
193:
194: END IF;

Line 197: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;

193:
194: END IF;
195: EXCEPTION
196: WHEN OTHERS THEN
197: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
198: x_msg_count := 1;
199: x_msg_data := substr(SQLERRM,1,25);
200:
201: IF ( G_LEVEL_STATEMENT >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 226: | FND_API.G_RET_STS_SUCCESS indicates that a

222: | p_release_reference
223: | p_release_date
224: |
225: | OUT x_return_status - Result of the API call:
226: | FND_API.G_RET_STS_SUCCESS indicates that a
227: | callout was invoked successfully.
228: | In this case the caller must COMMIT
229: | the status change.
230: |

Line 231: | FND_API.G_RET_STS_UNEXP_ERROR (or other) indicates

227: | callout was invoked successfully.
228: | In this case the caller must COMMIT
229: | the status change.
230: |
231: | FND_API.G_RET_STS_UNEXP_ERROR (or other) indicates
232: | that API did not complete successfully.
233: | In this case, the caller must issue a
234: | ROLLBACK to undo all status changes.
235: | x_msg_count

Line 269: x_return_status := FND_API.G_RET_STS_SUCCESS;

265:
266: WHERE
267: PAYMENT_ID = p_payment_id;
268:
269: x_return_status := FND_API.G_RET_STS_SUCCESS;
270: IF ( G_LEVEL_STATEMENT >= G_CURRENT_RUNTIME_LEVEL) THEN
271: print_debuginfo(l_module_name, 'EXIT');
272:
273: END IF;

Line 276: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;

272:
273: END IF;
274: EXCEPTION
275: WHEN OTHERS THEN
276: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
277: x_msg_count := 1;
278: x_msg_data := substr(SQLERRM,1,25);
279:
280: IF ( G_LEVEL_STATEMENT >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 309: | FND_API.G_RET_STS_SUCCESS indicates that a

305: | be removed.
306: |
307: | OUT
308: | x_return_status - Result of the API call:
309: | FND_API.G_RET_STS_SUCCESS indicates that a
310: | callout was invoked successfully.
311: | In this case the caller must COMMIT
312: | the status change.
313: |

Line 314: | FND_API.G_RET_STS_ERROR (or other) indicates

310: | callout was invoked successfully.
311: | In this case the caller must COMMIT
312: | the status change.
313: |
314: | FND_API.G_RET_STS_ERROR (or other) indicates
315: | that API did not complete successfully.
316: | In this case, the caller must issue a
317: | ROLLBACK to undo all status changes.
318: |

Line 477: IN FND_API.G_FALSE,

473: EXECUTE IMMEDIATE
474: (l_stmt)
475: USING
476: IN l_api_version,
477: IN FND_API.G_FALSE,
478: IN FND_API.G_FALSE,
479: OUT x_return_status,
480: OUT l_msg_count,
481: OUT l_msg_data,

Line 478: IN FND_API.G_FALSE,

474: (l_stmt)
475: USING
476: IN l_api_version,
477: IN FND_API.G_FALSE,
478: IN FND_API.G_FALSE,
479: OUT x_return_status,
480: OUT l_msg_count,
481: OUT l_msg_data,
482: IN l_rejection_id

Line 490: x_return_status <> FND_API.G_RET_STS_SUCCESS) THEN

486: * If the called procedure did not return success,
487: * raise an exception.
488: */
489: IF (x_return_status IS NULL OR
490: x_return_status <> FND_API.G_RET_STS_SUCCESS) THEN
491:
492:
493: print_debuginfo(l_module_name, 'Fatal: External app callout '''
494: || l_callout_name

Line 535: x_return_status := FND_API.G_RET_STS_SUCCESS;

531: */
532: RAISE;
533: END;
534:
535: x_return_status := FND_API.G_RET_STS_SUCCESS;
536:
537: IF ( G_LEVEL_STATEMENT >= G_CURRENT_RUNTIME_LEVEL) THEN
538: print_debuginfo(l_module_name, 'EXIT');
539:

Line 557: x_return_status := FND_API.G_RET_STS_ERROR;

553: print_debuginfo(l_module_name, 'SQLCODE: ' || SQLCODE);
554: print_debuginfo(l_module_name, 'SQLERRM: ' || SQLERRM);
555: END IF;
556: FND_MSG_PUB.add_exc_msg(G_PKG_NAME, l_module_name, null);
557: x_return_status := FND_API.G_RET_STS_ERROR;
558:
559: IF ( G_LEVEL_STATEMENT >= G_CURRENT_RUNTIME_LEVEL) THEN
560: print_debuginfo(l_module_name, 'EXIT');
561:

Line 587: | FND_API.G_RET_STS_SUCCESS indicates that all

583: | be removed. This should be an array of statuses.
584: |
585: | OUT
586: | x_return_status - Result of the API call:
587: | FND_API.G_RET_STS_SUCCESS indicates that all
588: | callouts were invoked successfully.
589: | In this case the caller must COMMIT
590: | the status changes.
591: |

Line 592: | FND_API.G_RET_STS_ERROR (or other) indicates

588: | callouts were invoked successfully.
589: | In this case the caller must COMMIT
590: | the status changes.
591: |
592: | FND_API.G_RET_STS_ERROR (or other) indicates
593: | that at least one event did not complete
594: | successfully. In this case, the caller must
595: | issue a ROLLBACK to undo all status changes.
596: |

Line 649: x_return_status := FND_API.G_RET_STS_ERROR;

645: || '. Returning failure response .. '
646: );
647:
648: END IF;
649: x_return_status := FND_API.G_RET_STS_ERROR;
650:
651: IF ( G_LEVEL_STATEMENT >= G_CURRENT_RUNTIME_LEVEL) THEN
652: print_debuginfo(l_module_name, 'EXIT');
653:

Line 669: x_return_status := FND_API.G_RET_STS_ERROR;

665: || '. Returning failure response .. '
666: );
667:
668: END IF;
669: x_return_status := FND_API.G_RET_STS_ERROR;
670:
671: IF ( G_LEVEL_STATEMENT >= G_CURRENT_RUNTIME_LEVEL) THEN
672: print_debuginfo(l_module_name, 'EXIT');
673:

Line 779: IN FND_API.G_FALSE,

775: EXECUTE IMMEDIATE
776: (l_stmt)
777: USING
778: IN l_api_version,
779: IN FND_API.G_FALSE,
780: IN FND_API.G_FALSE,
781: OUT x_return_status,
782: OUT l_msg_count,
783: OUT l_msg_data,

Line 780: IN FND_API.G_FALSE,

776: (l_stmt)
777: USING
778: IN l_api_version,
779: IN FND_API.G_FALSE,
780: IN FND_API.G_FALSE,
781: OUT x_return_status,
782: OUT l_msg_count,
783: OUT l_msg_data,
784: IN l_rejection_id

Line 791: x_return_status <> FND_API.G_RET_STS_SUCCESS) THEN

787: * If the called procedure did not return success,
788: * raise an exception.
789: */
790: IF (x_return_status IS NULL OR
791: x_return_status <> FND_API.G_RET_STS_SUCCESS) THEN
792:
793:
794: print_debuginfo(l_module_name, 'Fatal: External app callout '''
795: || l_callout_name

Line 836: x_return_status := FND_API.G_RET_STS_SUCCESS;

832: */
833: RAISE;
834: END;
835:
836: x_return_status := FND_API.G_RET_STS_SUCCESS;
837:
838: IF ( G_LEVEL_STATEMENT >= G_CURRENT_RUNTIME_LEVEL) THEN
839: print_debuginfo(l_module_name, 'Returning success response ..');
840:

Line 858: x_return_status := FND_API.G_RET_STS_ERROR;

854: print_debuginfo(l_module_name, 'SQLCODE: ' || SQLCODE);
855: print_debuginfo(l_module_name, 'SQLERRM: ' || SQLERRM);
856: END IF;
857: FND_MSG_PUB.add_exc_msg(G_PKG_NAME, l_module_name, null);
858: x_return_status := FND_API.G_RET_STS_ERROR;
859:
860: IF ( G_LEVEL_STATEMENT >= G_CURRENT_RUNTIME_LEVEL) THEN
861: print_debuginfo(l_module_name, 'EXIT');
862:

Line 888: | FND_API.G_RET_STS_SUCCESS indicates that

884: | be removed.
885: |
886: | OUT
887: | x_return_status - Result of the API call:
888: | FND_API.G_RET_STS_SUCCESS indicates that
889: | the callout was invoked successfully.
890: | In this case the caller must COMMIT
891: | the status changes.
892: |

Line 893: | FND_API.G_RET_STS_ERROR (or other) indicates

889: | the callout was invoked successfully.
890: | In this case the caller must COMMIT
891: | the status changes.
892: |
893: | FND_API.G_RET_STS_ERROR (or other) indicates
894: | that tha API did not complete successfully.
895: | In this case, the caller must issue a
896: | ROLLBACK to undo all status changes.
897: |

Line 1072: IN FND_API.G_FALSE,

1068: EXECUTE IMMEDIATE
1069: (l_stmt)
1070: USING
1071: IN l_api_version,
1072: IN FND_API.G_FALSE,
1073: IN FND_API.G_FALSE,
1074: OUT x_return_status,
1075: OUT l_msg_count,
1076: OUT l_msg_data,

Line 1073: IN FND_API.G_FALSE,

1069: (l_stmt)
1070: USING
1071: IN l_api_version,
1072: IN FND_API.G_FALSE,
1073: IN FND_API.G_FALSE,
1074: OUT x_return_status,
1075: OUT l_msg_count,
1076: OUT l_msg_data,
1077: IN l_rejection_id

Line 1085: x_return_status <> FND_API.G_RET_STS_SUCCESS) THEN

1081: * If the called procedure did not return success,
1082: * raise an exception.
1083: */
1084: IF (x_return_status IS NULL OR
1085: x_return_status <> FND_API.G_RET_STS_SUCCESS) THEN
1086:
1087:
1088: print_debuginfo(l_module_name, 'Fatal: External app callout '''
1089: || l_callout_name

Line 1131: x_return_status := FND_API.G_RET_STS_SUCCESS;

1127: RAISE;
1128: END;
1129:
1130:
1131: x_return_status := FND_API.G_RET_STS_SUCCESS;
1132:
1133: IF ( G_LEVEL_STATEMENT >= G_CURRENT_RUNTIME_LEVEL) THEN
1134: print_debuginfo(l_module_name, 'EXIT');
1135:

Line 1154: x_return_status := FND_API.G_RET_STS_ERROR;

1150: print_debuginfo(l_module_name, 'SQLERRM: ' || SQLERRM);
1151: END IF;
1152: FND_MSG_PUB.add_exc_msg(G_PKG_NAME, l_module_name, null);
1153:
1154: x_return_status := FND_API.G_RET_STS_ERROR;
1155:
1156: IF ( G_LEVEL_STATEMENT >= G_CURRENT_RUNTIME_LEVEL) THEN
1157: print_debuginfo(l_module_name, 'EXIT');
1158:

Line 1186: | FND_API.G_RET_STS_SUCCESS indicates that all

1182: | be removed. This should be an array of statuses.
1183: |
1184: | OUT
1185: | x_return_status - Result of the API call:
1186: | FND_API.G_RET_STS_SUCCESS indicates that all
1187: | the callouts were invoked successfully.
1188: | In this case the caller must COMMIT
1189: | the status changes.
1190: |

Line 1191: | FND_API.G_RET_STS_ERROR (or other) indicates

1187: | the callouts were invoked successfully.
1188: | In this case the caller must COMMIT
1189: | the status changes.
1190: |
1191: | FND_API.G_RET_STS_ERROR (or other) indicates
1192: | that at least one event did not complete
1193: | successfully. In this case, the caller must
1194: | issue a ROLLBACK to undo all status changes.
1195: |

Line 1237: x_return_status := FND_API.G_RET_STS_ERROR;

1233: || '. Returning failure response .. '
1234: );
1235:
1236: END IF;
1237: x_return_status := FND_API.G_RET_STS_ERROR;
1238:
1239: IF ( G_LEVEL_STATEMENT >= G_CURRENT_RUNTIME_LEVEL) THEN
1240: print_debuginfo(l_module_name, 'EXIT');
1241:

Line 1256: x_return_status := FND_API.G_RET_STS_ERROR;

1252: || 'Returning failure response .. '
1253: );
1254:
1255: END IF;
1256: x_return_status := FND_API.G_RET_STS_ERROR;
1257:
1258: IF ( G_LEVEL_STATEMENT >= G_CURRENT_RUNTIME_LEVEL) THEN
1259: print_debuginfo(l_module_name, 'EXIT');
1260:

Line 1281: x_return_status <> FND_API.G_RET_STS_SUCCESS) THEN

1277: /*
1278: * Check if the call to remove the payment succeeded.
1279: */
1280: IF (x_return_status IS NULL OR
1281: x_return_status <> FND_API.G_RET_STS_SUCCESS) THEN
1282:
1283: /*
1284: * Even if a single call to remove a payment
1285: * failed, return failure for the entire API request.

Line 1306: x_return_status := FND_API.G_RET_STS_SUCCESS;

1302: END IF;
1303:
1304: END LOOP;
1305:
1306: x_return_status := FND_API.G_RET_STS_SUCCESS;
1307:
1308: IF ( G_LEVEL_STATEMENT >= G_CURRENT_RUNTIME_LEVEL) THEN
1309: print_debuginfo(l_module_name, 'Returning success response ..');
1310:

Line 1336: | FND_API.G_RET_STS_SUCCESS indicates that all

1332: | specified payment request will be removed.
1333: |
1334: | OUT
1335: | x_return_status - Result of the API call:
1336: | FND_API.G_RET_STS_SUCCESS indicates that all
1337: | the callouts were invoked successfully.
1338: | In this case the caller must COMMIT
1339: | the status changes.
1340: |

Line 1341: | FND_API.G_RET_STS_ERROR (or other) indicates

1337: | the callouts were invoked successfully.
1338: | In this case the caller must COMMIT
1339: | the status changes.
1340: |
1341: | FND_API.G_RET_STS_ERROR (or other) indicates
1342: | that at least one event did not complete
1343: | successfully. In this case, the caller must
1344: | issue a ROLLBACK to undo all status changes.
1345: |

Line 1433: x_return_status <> FND_API.G_RET_STS_SUCCESS) THEN

1429: /*
1430: * Check if the call to remove the documents succeeded.
1431: */
1432: IF (x_return_status IS NULL OR
1433: x_return_status <> FND_API.G_RET_STS_SUCCESS) THEN
1434:
1435: /*
1436: * Even if a single call to remove a document
1437: * failed, return failure for the entire API request.

Line 1469: x_return_status := FND_API.G_RET_STS_SUCCESS;

1465:
1466: END IF;
1467: END IF;
1468:
1469: x_return_status := FND_API.G_RET_STS_SUCCESS;
1470:
1471: IF ( G_LEVEL_STATEMENT >= G_CURRENT_RUNTIME_LEVEL) THEN
1472: print_debuginfo(l_module_name, 'Returning success response ..');
1473:

Line 1501: | FND_API.G_RET_STS_SUCCESS indicates that the

1497: | be stopped.
1498: |
1499: | OUT
1500: | x_return_status - Result of the API call:
1501: | FND_API.G_RET_STS_SUCCESS indicates that the
1502: | callout was invoked successfully.
1503: | In this case the caller must COMMIT
1504: | the status changes.
1505: |

Line 1506: | FND_API.G_RET_STS_ERROR (or other) indicates

1502: | callout was invoked successfully.
1503: | In this case the caller must COMMIT
1504: | the status changes.
1505: |
1506: | FND_API.G_RET_STS_ERROR (or other) indicates
1507: | that tha API did not complete successfully.
1508: | In this case, the caller must issue a
1509: | ROLLBACK to undo all status changes.
1510: |

Line 1767: IN FND_API.G_FALSE,

1763: EXECUTE IMMEDIATE
1764: (l_stmt)
1765: USING
1766: IN l_api_version,
1767: IN FND_API.G_FALSE,
1768: IN FND_API.G_FALSE,
1769: OUT x_return_status,
1770: OUT l_msg_count,
1771: OUT l_msg_data,

Line 1768: IN FND_API.G_FALSE,

1764: (l_stmt)
1765: USING
1766: IN l_api_version,
1767: IN FND_API.G_FALSE,
1768: IN FND_API.G_FALSE,
1769: OUT x_return_status,
1770: OUT l_msg_count,
1771: OUT l_msg_data,
1772: IN l_rejection_id

Line 1780: x_return_status <> FND_API.G_RET_STS_SUCCESS) THEN

1776: * If the called procedure did not return success,
1777: * raise an exception.
1778: */
1779: IF (x_return_status IS NULL OR
1780: x_return_status <> FND_API.G_RET_STS_SUCCESS) THEN
1781:
1782:
1783: print_debuginfo(l_module_name, 'Fatal: External app callout '''
1784: || l_callout_name

Line 1824: x_return_status := FND_API.G_RET_STS_SUCCESS;

1820: */
1821: RAISE;
1822: END;
1823:
1824: x_return_status := FND_API.G_RET_STS_SUCCESS;
1825:
1826: IF ( G_LEVEL_STATEMENT >= G_CURRENT_RUNTIME_LEVEL) THEN
1827: print_debuginfo(l_module_name, 'EXIT');
1828:

Line 1847: x_return_status := FND_API.G_RET_STS_ERROR;

1843: print_debuginfo(l_module_name, 'SQLERRM: ' || SQLERRM);
1844: END IF;
1845: FND_MSG_PUB.add_exc_msg(G_PKG_NAME, l_module_name, null);
1846:
1847: x_return_status := FND_API.G_RET_STS_ERROR;
1848:
1849: IF ( G_LEVEL_STATEMENT >= G_CURRENT_RUNTIME_LEVEL) THEN
1850: print_debuginfo(l_module_name, 'EXIT');
1851:

Line 1879: | FND_API.G_RET_STS_SUCCESS indicates that all

1875: | be stopped. This should be an array of statuses.
1876: |
1877: | OUT
1878: | x_return_status - Result of the API call:
1879: | FND_API.G_RET_STS_SUCCESS indicates that all
1880: | the callouts were invoked successfully.
1881: | In this case the caller must COMMIT
1882: | the status changes.
1883: |

Line 1884: | FND_API.G_RET_STS_ERROR (or other) indicates

1880: | the callouts were invoked successfully.
1881: | In this case the caller must COMMIT
1882: | the status changes.
1883: |
1884: | FND_API.G_RET_STS_ERROR (or other) indicates
1885: | that at least one event did not complete
1886: | successfully. In this case, the caller must
1887: | issue a ROLLBACK to undo all status changes.
1888: |

Line 1930: x_return_status := FND_API.G_RET_STS_ERROR;

1926: || '. Returning failure response .. '
1927: );
1928:
1929: END IF;
1930: x_return_status := FND_API.G_RET_STS_ERROR;
1931:
1932: IF ( G_LEVEL_STATEMENT >= G_CURRENT_RUNTIME_LEVEL) THEN
1933: print_debuginfo(l_module_name, 'EXIT');
1934:

Line 1949: x_return_status := FND_API.G_RET_STS_ERROR;

1945: || 'Returning failure response .. '
1946: );
1947:
1948: END IF;
1949: x_return_status := FND_API.G_RET_STS_ERROR;
1950:
1951: IF ( G_LEVEL_STATEMENT >= G_CURRENT_RUNTIME_LEVEL) THEN
1952: print_debuginfo(l_module_name, 'EXIT');
1953:

Line 1974: x_return_status <> FND_API.G_RET_STS_SUCCESS) THEN

1970: /*
1971: * Check if the call to stop the payment succeeded.
1972: */
1973: IF (x_return_status IS NULL OR
1974: x_return_status <> FND_API.G_RET_STS_SUCCESS) THEN
1975:
1976: /*
1977: * Even if a single call to stop a payment
1978: * failed, return failure for the entire API request.

Line 1999: x_return_status := FND_API.G_RET_STS_SUCCESS;

1995: END IF;
1996:
1997: END LOOP;
1998:
1999: x_return_status := FND_API.G_RET_STS_SUCCESS;
2000:
2001: IF ( G_LEVEL_STATEMENT >= G_CURRENT_RUNTIME_LEVEL) THEN
2002: print_debuginfo(l_module_name, 'Returning success response ..');
2003:

Line 2026: | p_init_msg_list - Standard API parameter; default as FND_API.G_FALSE

2022: | PARAMETERS:
2023: | IN
2024: | p_api_version - Version of the API.
2025: |
2026: | p_init_msg_list - Standard API parameter; default as FND_API.G_FALSE
2027: |
2028: | p_pmt_id - ID of the payment to be voided. This id will map
2029: | to IBY_PAYMENTS_ALL.PAYMENT_ID column.
2030: |

Line 2041: | FND_API.G_RET_STS_SUCCESS

2037: | p_void_reason - Reason why this payment needs to be voided.
2038: |
2039: | OUT
2040: | x_return_status - Standard return status. Possible values are:
2041: | FND_API.G_RET_STS_SUCCESS
2042: | API completed successfully. Caller must
2043: | now COMMIT the database changes.
2044: |
2045: | FND_API.G_RET_STS_ERROR

Line 2045: | FND_API.G_RET_STS_ERROR

2041: | FND_API.G_RET_STS_SUCCESS
2042: | API completed successfully. Caller must
2043: | now COMMIT the database changes.
2044: |
2045: | FND_API.G_RET_STS_ERROR
2046: | API call failed. Caller must ROLLBACK any
2047: | base changes.
2048: |
2049: | x_msg_count - Standard msg count

Line 2064: p_init_msg_list IN VARCHAR2 DEFAULT FND_API.G_FALSE,

2060: |
2061: *---------------------------------------------------------------------*/
2062: PROCEDURE void_payment (
2063: p_api_version IN NUMBER,
2064: p_init_msg_list IN VARCHAR2 DEFAULT FND_API.G_FALSE,
2065: p_pmt_id IN NUMBER,
2066: p_voided_by IN NUMBER,
2067: p_void_date IN DATE,
2068: p_void_reason IN VARCHAR2,

Line 2103: IF NOT FND_API.Compatible_API_Call(

2099: );
2100:
2101: END IF;
2102: /* Standard call to check for API compatibility */
2103: IF NOT FND_API.Compatible_API_Call(
2104: l_api_version,
2105: p_api_version,
2106: l_api_name,
2107: G_PKG_NAME) THEN

Line 2109: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;

2105: p_api_version,
2106: l_api_name,
2107: G_PKG_NAME) THEN
2108:
2109: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
2110:
2111: END IF;
2112:
2113: /* Initialize message list if p_init_msg_list is set to TRUE */

Line 2114: IF FND_API.to_boolean(p_init_msg_list) THEN

2110:
2111: END IF;
2112:
2113: /* Initialize message list if p_init_msg_list is set to TRUE */
2114: IF FND_API.to_boolean(p_init_msg_list) THEN
2115: FND_MSG_PUB.initialize;
2116: END IF;
2117:
2118: /* Initialize return status */

Line 2119: x_return_status := FND_API.G_RET_STS_SUCCESS;

2115: FND_MSG_PUB.initialize;
2116: END IF;
2117:
2118: /* Initialize return status */
2119: x_return_status := FND_API.G_RET_STS_SUCCESS;
2120:
2121: /*
2122: * STEP I:
2123: *

Line 2324: p_encoded => FND_API.G_FALSE,

2320: * Standard call to get message count and if count is 1, get
2321: * message info.
2322: */
2323: FND_MSG_PUB.Count_And_Get(
2324: p_encoded => FND_API.G_FALSE,
2325: p_count => x_msg_count,
2326: p_data => x_msg_data
2327: );
2328:

Line 2329: x_return_status := FND_API.G_RET_STS_SUCCESS;

2325: p_count => x_msg_count,
2326: p_data => x_msg_data
2327: );
2328:
2329: x_return_status := FND_API.G_RET_STS_SUCCESS;
2330: IF ( G_LEVEL_STATEMENT >= G_CURRENT_RUNTIME_LEVEL) THEN
2331: print_debuginfo(l_module_name, 'Returning success response ..');
2332:
2333: print_debuginfo(l_module_name, 'EXIT');

Line 2351: x_return_status := FND_API.G_RET_STS_ERROR;

2347: print_debuginfo(l_module_name, 'SQL err msg: '|| SQLERRM);
2348: END IF;
2349: FND_MSG_PUB.add_exc_msg(G_PKG_NAME, l_module_name, null);
2350:
2351: x_return_status := FND_API.G_RET_STS_ERROR;
2352:
2353: FND_MSG_PUB.Count_And_Get(
2354: p_encoded => FND_API.G_FALSE,
2355: p_count => x_msg_count,

Line 2354: p_encoded => FND_API.G_FALSE,

2350:
2351: x_return_status := FND_API.G_RET_STS_ERROR;
2352:
2353: FND_MSG_PUB.Count_And_Get(
2354: p_encoded => FND_API.G_FALSE,
2355: p_count => x_msg_count,
2356: p_data => x_msg_data
2357: );
2358:

Line 2384: | p_init_msg_list - Standard API parameter; default as FND_API.G_FALSE

2380: | PARAMETERS:
2381: | IN
2382: | p_api_version - Version of the API.
2383: |
2384: | p_init_msg_list - Standard API parameter; default as FND_API.G_FALSE
2385: |
2386: | p_pmt_id - ID of the payment to be voided. This id will map
2387: | to IBY_PAYMENTS_ALL.PAYMENT_ID column.
2388: |

Line 2399: | FND_API.G_RET_STS_SUCCESS

2395: | p_void_reason - Reason why this payment needs to be voided.
2396: |
2397: | OUT
2398: | x_return_status - Standard return status. Possible values are:
2399: | FND_API.G_RET_STS_SUCCESS
2400: | API completed successfully. Caller must
2401: | now COMMIT the database changes.
2402: |
2403: | FND_API.G_RET_STS_ERROR

Line 2403: | FND_API.G_RET_STS_ERROR

2399: | FND_API.G_RET_STS_SUCCESS
2400: | API completed successfully. Caller must
2401: | now COMMIT the database changes.
2402: |
2403: | FND_API.G_RET_STS_ERROR
2404: | API call failed. Caller must ROLLBACK any
2405: | base changes.
2406: |
2407: | x_msg_count - Standard msg count

Line 2422: p_init_msg_list IN VARCHAR2 DEFAULT FND_API.G_FALSE,

2418: |
2419: *---------------------------------------------------------------------*/
2420: PROCEDURE void_pmt_internal (
2421: p_api_version IN NUMBER,
2422: p_init_msg_list IN VARCHAR2 DEFAULT FND_API.G_FALSE,
2423: p_pmt_id IN NUMBER,
2424: p_voided_by IN NUMBER,
2425: p_void_date IN DATE,
2426: p_void_reason IN VARCHAR2,

Line 2568: IF NOT FND_API.Compatible_API_Call(

2564: */
2565: /*---- end ----*/
2566:
2567: /* Standard call to check for API compatibility */
2568: IF NOT FND_API.Compatible_API_Call(
2569: l_api_version,
2570: p_api_version,
2571: l_api_name,
2572: G_PKG_NAME) THEN

Line 2574: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;

2570: p_api_version,
2571: l_api_name,
2572: G_PKG_NAME) THEN
2573:
2574: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
2575:
2576: END IF;
2577:
2578: /* Initialize message list if p_init_msg_list is set to TRUE */

Line 2579: IF FND_API.to_boolean(p_init_msg_list) THEN

2575:
2576: END IF;
2577:
2578: /* Initialize message list if p_init_msg_list is set to TRUE */
2579: IF FND_API.to_boolean(p_init_msg_list) THEN
2580: FND_MSG_PUB.initialize;
2581: END IF;
2582:
2583: /* Initialize return status */

Line 2584: x_return_status := FND_API.G_RET_STS_SUCCESS;

2580: FND_MSG_PUB.initialize;
2581: END IF;
2582:
2583: /* Initialize return status */
2584: x_return_status := FND_API.G_RET_STS_SUCCESS;
2585:
2586: /*
2587: * Fix for bug 5623941:
2588: *

Line 2619: x_return_status := FND_API.G_RET_STS_SUCCESS;

2615: || ' is already voided. Skipping .. '
2616: );
2617:
2618: END IF;
2619: x_return_status := FND_API.G_RET_STS_SUCCESS;
2620:
2621: IF ( G_LEVEL_STATEMENT >= G_CURRENT_RUNTIME_LEVEL) THEN
2622: print_debuginfo(l_module_name, 'Returning success response ..');
2623: print_debuginfo(l_module_name, 'EXIT');

Line 2639: FND_API.G_FALSE,

2635: * further.
2636: */
2637: is_void_allowed (
2638: p_api_version,
2639: FND_API.G_FALSE,
2640: p_pmt_id,
2641: l_ret_flag,
2642: x_return_status,
2643: x_msg_count,

Line 2666: x_return_status := FND_API.G_RET_STS_ERROR;

2662: || 'Returning failure response.'
2663: );
2664:
2665: END IF;
2666: x_return_status := FND_API.G_RET_STS_ERROR;
2667:
2668: FND_MSG_PUB.Count_And_Get(
2669: p_encoded => FND_API.G_FALSE,
2670: p_count => x_msg_count,

Line 2669: p_encoded => FND_API.G_FALSE,

2665: END IF;
2666: x_return_status := FND_API.G_RET_STS_ERROR;
2667:
2668: FND_MSG_PUB.Count_And_Get(
2669: p_encoded => FND_API.G_FALSE,
2670: p_count => x_msg_count,
2671: p_data => x_msg_data
2672: );
2673:

Line 2954: IN FND_API.G_FALSE,

2950: USING
2951: IN l_api_version,
2952: IN p_pmt_id,
2953: IN p_void_date,
2954: IN FND_API.G_FALSE,
2955: IN FND_API.G_FALSE, /* commit flag */
2956: OUT x_return_status,
2957: OUT l_msg_count,
2958: OUT l_msg_data

Line 2955: IN FND_API.G_FALSE, /* commit flag */

2951: IN l_api_version,
2952: IN p_pmt_id,
2953: IN p_void_date,
2954: IN FND_API.G_FALSE,
2955: IN FND_API.G_FALSE, /* commit flag */
2956: OUT x_return_status,
2957: OUT l_msg_count,
2958: OUT l_msg_data
2959: ;

Line 2972: x_return_status <> FND_API.G_RET_STS_SUCCESS) THEN

2968: * If the called procedure did not return success,
2969: * raise an exception.
2970: */
2971: IF (x_return_status IS NULL OR
2972: x_return_status <> FND_API.G_RET_STS_SUCCESS) THEN
2973:
2974:
2975: print_debuginfo(l_module_name, 'Fatal: External app callout '''
2976: || l_callout_name

Line 3021: p_encoded => FND_API.G_FALSE,

3017: * Standard call to get message count and if count is 1, get
3018: * message info.
3019: */
3020: FND_MSG_PUB.Count_And_Get(
3021: p_encoded => FND_API.G_FALSE,
3022: p_count => x_msg_count,
3023: p_data => x_msg_data
3024: );
3025:

Line 3026: x_return_status := FND_API.G_RET_STS_SUCCESS;

3022: p_count => x_msg_count,
3023: p_data => x_msg_data
3024: );
3025:
3026: x_return_status := FND_API.G_RET_STS_SUCCESS;
3027: IF ( G_LEVEL_STATEMENT >= G_CURRENT_RUNTIME_LEVEL) THEN
3028: print_debuginfo(l_module_name, 'Returning success response ..');
3029:
3030: print_debuginfo(l_module_name, 'EXIT');

Line 3047: x_return_status := FND_API.G_RET_STS_ERROR;

3043: print_debuginfo(l_module_name, 'SQL err msg: '|| SQLERRM);
3044: END IF;
3045: FND_MSG_PUB.add_exc_msg(G_PKG_NAME, l_module_name, null);
3046:
3047: x_return_status := FND_API.G_RET_STS_ERROR;
3048:
3049: FND_MSG_PUB.Count_And_Get(
3050: p_encoded => FND_API.G_FALSE,
3051: p_count => x_msg_count,

Line 3050: p_encoded => FND_API.G_FALSE,

3046:
3047: x_return_status := FND_API.G_RET_STS_ERROR;
3048:
3049: FND_MSG_PUB.Count_And_Get(
3050: p_encoded => FND_API.G_FALSE,
3051: p_count => x_msg_count,
3052: p_data => x_msg_data
3053: );
3054:

Line 3086: p_init_msg_list IN VARCHAR2 DEFAULT FND_API.G_FALSE,

3082: |
3083: *---------------------------------------------------------------------*/
3084: PROCEDURE is_void_allowed (
3085: p_api_version IN NUMBER,
3086: p_init_msg_list IN VARCHAR2 DEFAULT FND_API.G_FALSE,
3087: p_pmt_id IN NUMBER,
3088: x_return_flag OUT NOCOPY VARCHAR2, /* 'Y'/'N' flag */
3089: x_return_status OUT NOCOPY VARCHAR2,
3090: x_msg_count OUT NOCOPY NUMBER,

Line 3135: IF NOT FND_API.Compatible_API_Call(

3131: print_debuginfo(l_module_name, 'ENTER');
3132:
3133: END IF;
3134: /* Standard call to check for API compatibility */
3135: IF NOT FND_API.Compatible_API_Call(
3136: l_api_version,
3137: p_api_version,
3138: l_api_name,
3139: G_PKG_NAME) THEN

Line 3141: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;

3137: p_api_version,
3138: l_api_name,
3139: G_PKG_NAME) THEN
3140:
3141: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
3142:
3143: END IF;
3144:
3145: /* Initialize message list if p_init_msg_list is set to TRUE */

Line 3146: IF FND_API.to_boolean(p_init_msg_list) THEN

3142:
3143: END IF;
3144:
3145: /* Initialize message list if p_init_msg_list is set to TRUE */
3146: IF FND_API.to_boolean(p_init_msg_list) THEN
3147: FND_MSG_PUB.initialize;
3148: END IF;
3149:
3150: /* Initialize return status */

Line 3151: x_return_status := FND_API.G_RET_STS_SUCCESS;

3147: FND_MSG_PUB.initialize;
3148: END IF;
3149:
3150: /* Initialize return status */
3151: x_return_status := FND_API.G_RET_STS_SUCCESS;
3152:
3153: /*
3154: * Get the application name of the calling app. This
3155: * will be used in the callout.

Line 3213: IN FND_API.G_FALSE,

3209: EXECUTE IMMEDIATE
3210: (l_stmt)
3211: USING
3212: IN l_api_version,
3213: IN FND_API.G_FALSE,
3214: IN FND_API.G_FALSE,
3215: IN p_pmt_id,
3216: OUT x_return_flag,
3217: OUT x_return_status,

Line 3214: IN FND_API.G_FALSE,

3210: (l_stmt)
3211: USING
3212: IN l_api_version,
3213: IN FND_API.G_FALSE,
3214: IN FND_API.G_FALSE,
3215: IN p_pmt_id,
3216: OUT x_return_flag,
3217: OUT x_return_status,
3218: OUT l_msg_count,

Line 3227: x_return_status <> FND_API.G_RET_STS_SUCCESS) THEN

3223: * If the called procedure did not return success,
3224: * raise an exception.
3225: */
3226: IF (x_return_status IS NULL OR
3227: x_return_status <> FND_API.G_RET_STS_SUCCESS) THEN
3228:
3229:
3230: print_debuginfo(l_module_name, 'Fatal: External app callout '''
3231: || l_callout_name

Line 3290: x_return_status := FND_API.G_RET_STS_SUCCESS;

3286: */
3287: RAISE;
3288: END;
3289:
3290: x_return_status := FND_API.G_RET_STS_SUCCESS;
3291:
3292: IF ( G_LEVEL_STATEMENT >= G_CURRENT_RUNTIME_LEVEL) THEN
3293: print_debuginfo(l_module_name, 'EXIT');
3294:

Line 3311: x_return_status := FND_API.G_RET_STS_ERROR;

3307: print_debuginfo(l_module_name, 'SQLERRM: ' || SQLERRM);
3308: END IF;
3309: FND_MSG_PUB.add_exc_msg(G_PKG_NAME, l_module_name, null);
3310:
3311: x_return_status := FND_API.G_RET_STS_ERROR;
3312:
3313: IF ( G_LEVEL_STATEMENT >= G_CURRENT_RUNTIME_LEVEL) THEN
3314: print_debuginfo(l_module_name, 'EXIT');
3315:

Line 3351: | FND_API.G_RET_STS_SUCCESS indicates that all

3347: | p_void_reason - Reason why this payment needs to be voided.
3348: |
3349: | OUT
3350: | x_return_status - Result of the API call:
3351: | FND_API.G_RET_STS_SUCCESS indicates that all
3352: | the callouts were invoked successfully.
3353: | In this case the caller must COMMIT
3354: | the status changes.
3355: |

Line 3356: | FND_API.G_RET_STS_ERROR (or other) indicates

3352: | the callouts were invoked successfully.
3353: | In this case the caller must COMMIT
3354: | the status changes.
3355: |
3356: | FND_API.G_RET_STS_ERROR (or other) indicates
3357: | that at least one event did not complete
3358: | successfully. In this case, the caller must
3359: | issue a ROLLBACK to undo all status changes.
3360: |

Line 3426: x_return_status := FND_API.G_RET_STS_ERROR;

3422: WHERE payment_instruction_id = p_instr_id AND
3423: payments_complete_flag = 'Y';
3424:
3425: IF(p_void_date < l_pmt_date) THEN
3426: x_return_status := FND_API.G_RET_STS_ERROR;
3427: fnd_message.set_name('IBY', 'IBY_VOID_DATE_BEF_PMT_DATE');
3428: fnd_message.set_Token('PMT_DATE', l_pmt_date);
3429: fnd_msg_pub.add;
3430: RETURN;

Line 3454: x_return_status := FND_API.G_RET_STS_ERROR;

3450: || p_instr_id
3451: );
3452:
3453: END IF;
3454: x_return_status := FND_API.G_RET_STS_ERROR;
3455:
3456: IF ( G_LEVEL_STATEMENT >= G_CURRENT_RUNTIME_LEVEL) THEN
3457: print_debuginfo(l_module_name, 'EXIT');
3458:

Line 3471: FND_API.G_FALSE,

3467: FOR i IN l_pmts_list.FIRST .. l_pmts_list.LAST LOOP
3468:
3469: void_pmt_internal (
3470: l_api_version,
3471: FND_API.G_FALSE,
3472: l_pmts_list(i),
3473: p_voided_by,
3474: p_void_date,
3475: p_void_reason,

Line 3485: x_return_status <> FND_API.G_RET_STS_SUCCESS) THEN

3481: /*
3482: * Check if the call to stop the payment succeeded.
3483: */
3484: IF (x_return_status IS NULL OR
3485: x_return_status <> FND_API.G_RET_STS_SUCCESS) THEN
3486:
3487: /*
3488: * Even if a single call to remove a payment
3489: * failed, return failure for the entire API request.

Line 3549: x_return_status := FND_API.G_RET_STS_SUCCESS;

3545: || ' set to TERMINATED because all payments have been voided.'
3546: );
3547:
3548: END IF;
3549: x_return_status := FND_API.G_RET_STS_SUCCESS;
3550:
3551: IF ( G_LEVEL_STATEMENT >= G_CURRENT_RUNTIME_LEVEL) THEN
3552: print_debuginfo(l_module_name, 'Returning success response ..');
3553:

Line 3571: | p_init_msg_list - Standard API parameter; default as FND_API.G_FALSE

3567: | PARAMETERS:
3568: | IN
3569: | p_api_version - Version of the API.
3570: |
3571: | p_init_msg_list - Standard API parameter; default as FND_API.G_FALSE
3572: |
3573: | p_payment_doc_id
3574: | - ID of the payment document (check stock) to use.
3575: |

Line 3585: | FND_API.G_RET_STS_SUCCESS

3581: | returned as an output parameter.
3582: |
3583: | OUT
3584: | x_return_status - Standard return status. Possible values are:
3585: | FND_API.G_RET_STS_SUCCESS
3586: | The given paper document number is valid
3587: | for the given payment document.
3588: |
3589: | It is possible that there were warnings.

Line 3594: | FND_API.G_RET_STS_ERROR

3590: | Please unwind the FND message stack to
3591: | check if there were any warnings to display
3592: | to the user.
3593: |
3594: | FND_API.G_RET_STS_ERROR
3595: | The given paper document number is invalid.
3596: | Possible reasons are the paper document number
3597: | has already been used, or the paper document
3598: | number is not in the valid range for the given

Line 3616: p_init_msg_list IN VARCHAR2 DEFAULT FND_API.G_FALSE,

3612: |
3613: *---------------------------------------------------------------------*/
3614: PROCEDURE validate_paper_doc_number (
3615: p_api_version IN NUMBER,
3616: p_init_msg_list IN VARCHAR2 DEFAULT FND_API.G_FALSE,
3617: p_payment_doc_id IN NUMBER,
3618: x_paper_doc_num IN OUT NOCOPY NUMBER,
3619: x_return_status OUT NOCOPY VARCHAR2,
3620: x_msg_count OUT NOCOPY NUMBER,

Line 3622: show_warn_msgs_flag IN VARCHAR2 DEFAULT FND_API.G_TRUE

3618: x_paper_doc_num IN OUT NOCOPY NUMBER,
3619: x_return_status OUT NOCOPY VARCHAR2,
3620: x_msg_count OUT NOCOPY NUMBER,
3621: x_msg_data OUT NOCOPY VARCHAR2,
3622: show_warn_msgs_flag IN VARCHAR2 DEFAULT FND_API.G_TRUE
3623: )
3624: IS
3625:
3626: l_module_name CONSTANT VARCHAR2(200) := G_PKG_NAME

Line 3651: IF NOT FND_API.Compatible_API_Call(

3647: print_debuginfo(l_module_name, 'ENTER');
3648:
3649: END IF;
3650: /* Standard call to check for API compatibility */
3651: IF NOT FND_API.Compatible_API_Call(
3652: l_api_version,
3653: p_api_version,
3654: l_api_name,
3655: G_PKG_NAME) THEN

Line 3657: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;

3653: p_api_version,
3654: l_api_name,
3655: G_PKG_NAME) THEN
3656:
3657: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
3658:
3659: END IF;
3660:
3661: /* Initialize message list if p_init_msg_list is set to TRUE */

Line 3662: IF FND_API.to_boolean(p_init_msg_list) THEN

3658:
3659: END IF;
3660:
3661: /* Initialize message list if p_init_msg_list is set to TRUE */
3662: IF FND_API.to_boolean(p_init_msg_list) THEN
3663: FND_MSG_PUB.initialize;
3664: END IF;
3665:
3666: /* Initialize return status */

Line 3667: x_return_status := FND_API.G_RET_STS_SUCCESS;

3663: FND_MSG_PUB.initialize;
3664: END IF;
3665:
3666: /* Initialize return status */
3667: x_return_status := FND_API.G_RET_STS_SUCCESS;
3668:
3669:
3670: /*
3671: * Pull up the details of the paper stock, like the

Line 3709: x_return_status := FND_API.G_RET_STS_ERROR;

3705: print_debuginfo(l_module_name, 'SQL err msg: '|| SQLERRM);
3706: END IF;
3707: FND_MSG_PUB.add_exc_msg(G_PKG_NAME, l_module_name, null);
3708:
3709: x_return_status := FND_API.G_RET_STS_ERROR;
3710:
3711: l_error_code := 'IBY_INS_NO_PMT_DOC';
3712: FND_MESSAGE.set_name('IBY', l_error_code);
3713:

Line 3746: x_return_status := FND_API.G_RET_STS_ERROR;

3742: print_debuginfo(l_module_name, 'SQL code: ' || SQLCODE);
3743: print_debuginfo(l_module_name, 'SQL err msg: '|| SQLERRM);
3744:
3745: END IF;
3746: x_return_status := FND_API.G_RET_STS_ERROR;
3747:
3748: l_error_code := 'IBY_PMT_DOC_EXCEPTION';
3749: FND_MESSAGE.set_name('IBY', l_error_code);
3750:

Line 3850: x_return_status := FND_API.G_RET_STS_SUCCESS;

3846: || 'available for issue.'
3847: );
3848:
3849: END IF;
3850: x_return_status := FND_API.G_RET_STS_SUCCESS;
3851:
3852: --Bug 8367408 : Paper document number should be reset per AP
3853: x_paper_doc_num := NULL;
3854:

Line 3894: x_return_status := FND_API.G_RET_STS_SUCCESS;

3890: x_paper_doc_num := -1;
3891:
3892: ELSE
3893:
3894: x_return_status := FND_API.G_RET_STS_SUCCESS;
3895:
3896: IF ( G_LEVEL_STATEMENT >= G_CURRENT_RUNTIME_LEVEL) THEN
3897: print_debuginfo(l_module_name, 'Generated paper document '
3898: || 'number '

Line 3940: x_return_status := FND_API.G_RET_STS_ERROR;

3936: || l_first_avail_check_num
3937: );
3938:
3939: END IF;
3940: x_return_status := FND_API.G_RET_STS_ERROR;
3941:
3942: l_error_code := 'IBY_DOC_NUM_BELOW_ALLOWED';
3943: FND_MESSAGE.set_name('IBY', l_error_code);
3944:

Line 3995: x_return_status := FND_API.G_RET_STS_ERROR;

3991: || l_last_avail_check_num
3992: );
3993:
3994: END IF;
3995: x_return_status := FND_API.G_RET_STS_ERROR;
3996:
3997: l_error_code := 'IBY_DOC_NUM_ABOVE_ALLOWED';
3998: FND_MESSAGE.set_name('IBY', l_error_code);
3999:

Line 4041: IF (show_warn_msgs_flag = FND_API.G_TRUE) THEN

4037: * By setting the show warnings flag to 'false' for
4038: * the single payments flow, the number of potential
4039: * messages displayed to the user is reduced.
4040: */
4041: IF (show_warn_msgs_flag = FND_API.G_TRUE) THEN
4042:
4043: IF ( G_LEVEL_STATEMENT >= G_CURRENT_RUNTIME_LEVEL) THEN
4044: print_debuginfo(l_module_name, 'Warning: Provided paper '
4045: || 'doc number '

Line 4082: x_return_status := FND_API.G_RET_STS_ERROR;

4078: || ' has already been used.'
4079: );
4080:
4081: END IF;
4082: x_return_status := FND_API.G_RET_STS_ERROR;
4083:
4084: l_error_code := 'IBY_DOC_NUM_USED';
4085: FND_MESSAGE.set_name('IBY', l_error_code);
4086:

Line 4122: x_return_status := FND_API.G_RET_STS_SUCCESS;

4118: IF ( G_LEVEL_STATEMENT >= G_CURRENT_RUNTIME_LEVEL) THEN
4119: print_debuginfo(l_module_name, 'Returning success response ..');
4120:
4121: END IF;
4122: x_return_status := FND_API.G_RET_STS_SUCCESS;
4123:
4124: IF ( G_LEVEL_STATEMENT >= G_CURRENT_RUNTIME_LEVEL) THEN
4125: print_debuginfo(l_module_name, 'EXIT');
4126:

Line 4143: | p_init_msg_list - Standard API parameter; default as FND_API.G_FALSE

4139: | PARAMETERS:
4140: | IN
4141: | p_api_version - Version of the API.
4142: |
4143: | p_init_msg_list - Standard API parameter; default as FND_API.G_FALSE
4144: |
4145: | p_payment_doc_id
4146: | - ID of the payment document (check stock) to use.
4147: |

Line 4150: | FND_API.G_RET_STS_SUCCESS

4146: | - ID of the payment document (check stock) to use.
4147: |
4148: | OUT
4149: | x_return_status - Standard return status. Possible values are:
4150: | FND_API.G_RET_STS_SUCCESS
4151: | The given payment document is valid
4152: | and it is not locked by any of Instructions or
4153: | with single payment.
4154: |

Line 4157: | FND_API.G_RET_STS_ERROR

4153: | with single payment.
4154: |
4155: |
4156: |
4157: | FND_API.G_RET_STS_ERROR
4158: | The given payment document is already locked.
4159: | Possible reasons are the payement document
4160: | has already locked by any Instruction, or
4161: | for single payment by another user.

Line 4178: p_init_msg_list IN VARCHAR2 DEFAULT FND_API.G_FALSE,

4174: |
4175: *---------------------------------------------------------------------*/
4176: PROCEDURE validate_payment_document (
4177: p_api_version IN NUMBER,
4178: p_init_msg_list IN VARCHAR2 DEFAULT FND_API.G_FALSE,
4179: p_payment_doc_id IN NUMBER,
4180: x_return_status OUT NOCOPY VARCHAR2,
4181: x_msg_count OUT NOCOPY NUMBER,
4182: x_msg_data OUT NOCOPY VARCHAR2

Line 4202: IF NOT FND_API.Compatible_API_Call(

4198: print_debuginfo(l_module_name, 'p_payment_doc_id:'||p_payment_doc_id);
4199:
4200: END IF;
4201: /* Standard call to check for API compatibility */
4202: IF NOT FND_API.Compatible_API_Call(
4203: l_api_version,
4204: p_api_version,
4205: l_api_name,
4206: G_PKG_NAME) THEN

Line 4208: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;

4204: p_api_version,
4205: l_api_name,
4206: G_PKG_NAME) THEN
4207:
4208: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
4209:
4210: END IF;
4211:
4212: /* Initialize message list if p_init_msg_list is set to TRUE */

Line 4213: IF FND_API.to_boolean(p_init_msg_list) THEN

4209:
4210: END IF;
4211:
4212: /* Initialize message list if p_init_msg_list is set to TRUE */
4213: IF FND_API.to_boolean(p_init_msg_list) THEN
4214: FND_MSG_PUB.initialize;
4215: END IF;
4216:
4217: /* Initialize return status */

Line 4218: x_return_status := FND_API.G_RET_STS_SUCCESS;

4214: FND_MSG_PUB.initialize;
4215: END IF;
4216:
4217: /* Initialize return status */
4218: x_return_status := FND_API.G_RET_STS_SUCCESS;
4219:
4220:
4221: /*
4222: * Pull up the name of the paper stock

Line 4249: x_return_status := FND_API.G_RET_STS_ERROR;

4245: print_debuginfo(l_module_name, 'SQL err msg: '|| SQLERRM);
4246: END IF;
4247: FND_MSG_PUB.add_exc_msg(G_PKG_NAME, l_module_name, null);
4248:
4249: x_return_status := FND_API.G_RET_STS_ERROR;
4250:
4251: l_error_code := 'IBY_INS_NO_PMT_DOC';
4252: FND_MESSAGE.set_name('IBY', l_error_code);
4253:

Line 4286: x_return_status := FND_API.G_RET_STS_ERROR;

4282: print_debuginfo(l_module_name, 'SQL code: ' || SQLCODE);
4283: print_debuginfo(l_module_name, 'SQL err msg: '|| SQLERRM);
4284:
4285: END IF;
4286: x_return_status := FND_API.G_RET_STS_ERROR;
4287:
4288: l_error_code := 'IBY_PMT_DOC_EXCEPTION';
4289: FND_MESSAGE.set_name('IBY', l_error_code);
4290:

Line 4329: x_return_status := FND_API.G_RET_STS_ERROR;

4325: || ' is locked by instruction'
4326: || l_pmt_instr_id
4327: );
4328: END IF;
4329: x_return_status := FND_API.G_RET_STS_ERROR;
4330:
4331: l_error_code := 'IBY_PAY_DOC_ALREADY_USE';
4332: FND_MESSAGE.set_name('IBY', l_error_code);
4333:

Line 4387: x_return_status := FND_API.G_RET_STS_ERROR;

4383: print_debuginfo(l_module_name, 'SQL err msg: '|| SQLERRM);
4384: END IF;
4385: --FND_MSG_PUB.add_exc_msg(G_PKG_NAME, l_module_name, null);
4386:
4387: x_return_status := FND_API.G_RET_STS_ERROR;
4388:
4389: l_error_code := 'IBY_PMT_DOC_UNAVAILABLE';
4390: FND_MESSAGE.set_name('IBY', l_error_code);
4391:

Line 4420: x_return_status := FND_API.G_RET_STS_ERROR;

4416: print_debuginfo(l_module_name, 'SQL code: ' || SQLCODE);
4417: print_debuginfo(l_module_name, 'SQL err msg: '|| SQLERRM);
4418:
4419: END IF;
4420: x_return_status := FND_API.G_RET_STS_ERROR;
4421:
4422: l_error_code := 'IBY_PMT_DOC_EXCEPTION';
4423: FND_MESSAGE.set_name('IBY', l_error_code);
4424:

Line 4651: x_return_status := FND_API.G_RET_STS_ERROR;

4647: || ' It cannot be terminated at present.'
4648: );
4649:
4650: END IF;
4651: x_return_status := FND_API.G_RET_STS_ERROR;
4652:
4653: l_error_code := 'IBY_INS_LOCKED';
4654: FND_MESSAGE.set_name('IBY', l_error_code);
4655: FND_MSG_PUB.ADD;

Line 4706: IN FND_API.G_FALSE,

4702: USING
4703: IN p_instr_id,
4704: IN 'TERMINATE',
4705: IN l_api_version,
4706: IN FND_API.G_FALSE,
4707: IN FND_API.G_FALSE,
4708: OUT x_return_status,
4709: OUT l_msg_count,
4710: OUT l_msg_data

Line 4707: IN FND_API.G_FALSE,

4703: IN p_instr_id,
4704: IN 'TERMINATE',
4705: IN l_api_version,
4706: IN FND_API.G_FALSE,
4707: IN FND_API.G_FALSE,
4708: OUT x_return_status,
4709: OUT l_msg_count,
4710: OUT l_msg_data
4711: ;

Line 4718: x_return_status <> FND_API.G_RET_STS_SUCCESS) THEN

4714: * If the called procedure did not return success,
4715: * raise an exception.
4716: */
4717: IF (x_return_status IS NULL OR
4718: x_return_status <> FND_API.G_RET_STS_SUCCESS) THEN
4719:
4720:
4721: print_debuginfo(l_module_name, 'Fatal: External app callout '''
4722: || l_callout_name

Line 5215: IN FND_API.G_FALSE,

5211: EXECUTE IMMEDIATE
5212: (l_stmt)
5213: USING
5214: IN l_api_version,
5215: IN FND_API.G_FALSE,
5216: IN FND_API.G_FALSE,
5217: OUT x_return_status,
5218: OUT l_msg_count,
5219: OUT l_msg_data,

Line 5216: IN FND_API.G_FALSE,

5212: (l_stmt)
5213: USING
5214: IN l_api_version,
5215: IN FND_API.G_FALSE,
5216: IN FND_API.G_FALSE,
5217: OUT x_return_status,
5218: OUT l_msg_count,
5219: OUT l_msg_data,
5220: IN l_rejection_id

Line 5228: x_return_status <> FND_API.G_RET_STS_SUCCESS) THEN

5224: * If the called procedure did not return success,
5225: * raise an exception.
5226: */
5227: IF (x_return_status IS NULL OR
5228: x_return_status <> FND_API.G_RET_STS_SUCCESS) THEN
5229:
5230:
5231: print_debuginfo(l_module_name, 'Fatal: External app callout '''
5232: || l_callout_name

Line 5302: x_return_status := FND_API.G_RET_STS_SUCCESS;

5298: 'PAYMENT_INSTRUCTION',
5299: l_ret_status
5300: );
5301:
5302: x_return_status := FND_API.G_RET_STS_SUCCESS;
5303:
5304: IF ( G_LEVEL_STATEMENT >= G_CURRENT_RUNTIME_LEVEL) THEN
5305: print_debuginfo(l_module_name, 'EXIT');
5306:

Line 5325: x_return_status := FND_API.G_RET_STS_ERROR;

5321: print_debuginfo(l_module_name, 'SQLERRM: ' || SQLERRM);
5322: END IF;
5323: FND_MSG_PUB.add_exc_msg(G_PKG_NAME, l_module_name, null);
5324:
5325: x_return_status := FND_API.G_RET_STS_ERROR;
5326:
5327: IF ( G_LEVEL_STATEMENT >= G_CURRENT_RUNTIME_LEVEL) THEN
5328: print_debuginfo(l_module_name, 'EXIT');
5329:

Line 5465: x_return_status := FND_API.G_RET_STS_ERROR;

5461: || ' It cannot be terminated at present.'
5462: );
5463:
5464: END IF;
5465: x_return_status := FND_API.G_RET_STS_ERROR;
5466:
5467: l_error_code := 'IBY_PPR_LOCKED';
5468: FND_MESSAGE.set_name('IBY', l_error_code);
5469: FND_MSG_PUB.ADD;

Line 5536: x_return_status := FND_API.G_RET_STS_ERROR;

5532: ' to other PPRs');
5533: print_debuginfo(l_module_name, 'Returning error message..');
5534:
5535: END IF;
5536: x_return_status := FND_API.G_RET_STS_ERROR;
5537: l_error_code := 'IBY_PPR_TERM_NOT_ALLOWED';
5538: FND_MESSAGE.set_name('IBY', l_error_code);
5539: FND_MSG_PUB.ADD;
5540:

Line 5556: x_return_status := FND_API.G_RET_STS_ERROR;

5552: ' can not be terminated');
5553: print_debuginfo(l_module_name, 'Returning error message..');
5554:
5555: END IF;
5556: x_return_status := FND_API.G_RET_STS_ERROR;
5557: l_error_code := 'IBY_PPR_TERM_NOT_ALLOWED';
5558: FND_MESSAGE.set_name('IBY', l_error_code);
5559: FND_MSG_PUB.ADD;
5560: return;

Line 5571: IF(x_return_status <> FND_API.G_RET_STS_SUCCESS) THEN

5567: FOR pmt_instr in pmt_instructions(p_req_id) loop
5568: terminate_pmt_instruction(pmt_instr.payment_instruction_id,
5569: pmt_instr.payment_instruction_status,
5570: x_return_status);
5571: IF(x_return_status <> FND_API.G_RET_STS_SUCCESS) THEN
5572: IF ( G_LEVEL_STATEMENT >= G_CURRENT_RUNTIME_LEVEL) THEN
5573: print_debuginfo(l_module_name, 'Exception while terminating Payment instruction '||
5574: pmt_instr.payment_instruction_id);
5575: print_debuginfo(l_module_name, 'Returning error message..');

Line 5578: x_return_status := FND_API.G_RET_STS_ERROR;

5574: pmt_instr.payment_instruction_id);
5575: print_debuginfo(l_module_name, 'Returning error message..');
5576:
5577: END IF;
5578: x_return_status := FND_API.G_RET_STS_ERROR;
5579: return;
5580: END IF;
5581: end loop;
5582:

Line 5587: x_return_status := FND_API.G_RET_STS_SUCCESS;

5583: END IF;
5584:
5585: COMMIT;
5586:
5587: x_return_status := FND_API.G_RET_STS_SUCCESS;
5588:
5589: IF ( G_LEVEL_STATEMENT >= G_CURRENT_RUNTIME_LEVEL) THEN
5590: print_debuginfo(l_module_name, 'EXIT');
5591:

Line 5735: x_return_status := FND_API.G_RET_STS_SUCCESS;

5731: * it is not worth proceeding further.
5732: *
5733: * Return success status to the caller.
5734: */
5735: x_return_status := FND_API.G_RET_STS_SUCCESS;
5736:
5737: IF ( G_LEVEL_STATEMENT >= G_CURRENT_RUNTIME_LEVEL) THEN
5738: print_debuginfo(l_module_name, 'EXIT');
5739: END IF;

Line 5856: IN FND_API.G_FALSE,

5852: EXECUTE IMMEDIATE
5853: (l_stmt)
5854: USING
5855: IN l_api_version,
5856: IN FND_API.G_FALSE,
5857: IN FND_API.G_FALSE,
5858: OUT x_return_status,
5859: OUT l_msg_count,
5860: OUT l_msg_data,

Line 5857: IN FND_API.G_FALSE,

5853: (l_stmt)
5854: USING
5855: IN l_api_version,
5856: IN FND_API.G_FALSE,
5857: IN FND_API.G_FALSE,
5858: OUT x_return_status,
5859: OUT l_msg_count,
5860: OUT l_msg_data,
5861: IN l_rejection_id

Line 5876: x_return_status <> FND_API.G_RET_STS_SUCCESS) THEN

5872: * If the called procedure did not return success,
5873: * raise an exception.
5874: */
5875: IF (x_return_status IS NULL OR
5876: x_return_status <> FND_API.G_RET_STS_SUCCESS) THEN
5877:
5878:
5879: print_debuginfo(l_module_name, 'Fatal: External app callout '''
5880: || l_callout_name

Line 5948: x_return_status := FND_API.G_RET_STS_SUCCESS;

5944: 'PAYMENT_REQUEST',
5945: l_ret_status
5946: );
5947:
5948: x_return_status := FND_API.G_RET_STS_SUCCESS;
5949:
5950: IF ( G_LEVEL_STATEMENT >= G_CURRENT_RUNTIME_LEVEL) THEN
5951: print_debuginfo(l_module_name, 'EXIT');
5952:

Line 5972: x_return_status := FND_API.G_RET_STS_ERROR;

5968: print_debuginfo(l_module_name, 'SQLERRM: ' || SQLERRM);
5969: END IF;
5970: FND_MSG_PUB.add_exc_msg(G_PKG_NAME, l_module_name, null);
5971:
5972: x_return_status := FND_API.G_RET_STS_ERROR;
5973:
5974: IF ( G_LEVEL_STATEMENT >= G_CURRENT_RUNTIME_LEVEL) THEN
5975: print_debuginfo(l_module_name, 'EXIT');
5976:

Line 6187: IF (l_ret_status <> FND_API.G_RET_STS_SUCCESS) THEN

6183:
6184: /*
6185: * If we are unable to lock the payment request, abort.
6186: */
6187: IF (l_ret_status <> FND_API.G_RET_STS_SUCCESS) THEN
6188:
6189:
6190: print_debuginfo(l_module_name, 'Unable to lock payment '
6191: || 'process request: '

Line 6357: IF (l_str_ret_status <> FND_API.G_RET_STS_SUCCESS) THEN

6353: x_conc_req_id,
6354: l_str_ret_status
6355: );
6356:
6357: IF (l_str_ret_status <> FND_API.G_RET_STS_SUCCESS) THEN
6358:
6359:
6360: print_debuginfo(l_module_name, 'Unable to lock payment '
6361: || 'instruction: '

Line 6453: | FND_API.G_RET_STS_SUCCESS indicates that the

6449: |
6450: |
6451: | OUT
6452: | x_return_status - Result of the API call:
6453: | FND_API.G_RET_STS_SUCCESS indicates that the
6454: | reprint process was triggered successfully.
6455: | In this case the caller must COMMIT
6456: | the status change.
6457: |

Line 6458: | FND_API.G_RET_STS_ERROR (or other) indicates

6454: | reprint process was triggered successfully.
6455: | In this case the caller must COMMIT
6456: | the status change.
6457: |
6458: | FND_API.G_RET_STS_ERROR (or other) indicates
6459: | that API did not complete successfully.
6460: | In this case, the caller must issue a
6461: | ROLLBACK to undo all status changes.
6462: |

Line 6548: x_return_status := FND_API.G_RET_STS_ERROR;

6544: || '. Returning failure response .. '
6545: );
6546:
6547: END IF;
6548: x_return_status := FND_API.G_RET_STS_ERROR;
6549:
6550: IF ( G_LEVEL_STATEMENT >= G_CURRENT_RUNTIME_LEVEL) THEN
6551: print_debuginfo(l_module_name, 'EXIT');
6552:

Line 6568: x_return_status := FND_API.G_RET_STS_ERROR;

6564: || 'Returning failure response .. '
6565: );
6566:
6567: END IF;
6568: x_return_status := FND_API.G_RET_STS_ERROR;
6569:
6570: IF ( G_LEVEL_STATEMENT >= G_CURRENT_RUNTIME_LEVEL) THEN
6571: print_debuginfo(l_module_name, 'EXIT');
6572:

Line 6820: IN FND_API.G_FALSE,

6816: USING
6817: IN p_instr_id,
6818: IN 'REPRINT',
6819: IN l_api_version,
6820: IN FND_API.G_FALSE,
6821: IN FND_API.G_FALSE,
6822: OUT x_return_status,
6823: OUT l_msg_count,
6824: OUT l_msg_data

Line 6821: IN FND_API.G_FALSE,

6817: IN p_instr_id,
6818: IN 'REPRINT',
6819: IN l_api_version,
6820: IN FND_API.G_FALSE,
6821: IN FND_API.G_FALSE,
6822: OUT x_return_status,
6823: OUT l_msg_count,
6824: OUT l_msg_data
6825: ;

Line 6836: x_return_status <> FND_API.G_RET_STS_SUCCESS) THEN

6832: * If the called procedure did not return success,
6833: * raise an exception.
6834: */
6835: IF (x_return_status IS NULL OR
6836: x_return_status <> FND_API.G_RET_STS_SUCCESS) THEN
6837:
6838:
6839: print_debuginfo(l_module_name, 'Fatal: External app callout '''
6840: || l_callout_name

Line 6894: x_return_status := FND_API.G_RET_STS_SUCCESS;

6890: p_instr_id,
6891: 'Y'
6892: );
6893:
6894: x_return_status := FND_API.G_RET_STS_SUCCESS;
6895:
6896: IF ( G_LEVEL_STATEMENT >= G_CURRENT_RUNTIME_LEVEL) THEN
6897: print_debuginfo(l_module_name, 'Returning success response ..');
6898:

Line 6916: x_return_status := FND_API.G_RET_STS_ERROR;

6912: print_debuginfo(l_module_name, 'SQLERRM: ' || SQLERRM);
6913: END IF;
6914: FND_MSG_PUB.add_exc_msg(G_PKG_NAME, l_module_name, null);
6915:
6916: x_return_status := FND_API.G_RET_STS_ERROR;
6917:
6918: IF ( G_LEVEL_STATEMENT >= G_CURRENT_RUNTIME_LEVEL) THEN
6919: print_debuginfo(l_module_name, 'EXIT');
6920:

Line 6962: | FND_API.G_RET_STS_SUCCESS indicates that the

6958: |
6959: |
6960: | OUT
6961: | x_return_status - Result of the API call:
6962: | FND_API.G_RET_STS_SUCCESS indicates that the
6963: | reprint process was triggered successfully.
6964: | In this case the caller must COMMIT
6965: | the status change.
6966: |

Line 6967: | FND_API.G_RET_STS_ERROR (or other) indicates

6963: | reprint process was triggered successfully.
6964: | In this case the caller must COMMIT
6965: | the status change.
6966: |
6967: | FND_API.G_RET_STS_ERROR (or other) indicates
6968: | that API did not complete successfully.
6969: | In this case, the caller must issue a
6970: | ROLLBACK to undo all status changes.
6971: |

Line 7038: x_return_status := FND_API.G_RET_STS_ERROR;

7034: || '. Returning failure response .. '
7035: );
7036:
7037: END IF;
7038: x_return_status := FND_API.G_RET_STS_ERROR;
7039:
7040: IF ( G_LEVEL_STATEMENT >= G_CURRENT_RUNTIME_LEVEL) THEN
7041: print_debuginfo(l_module_name, 'EXIT');
7042:

Line 7111: x_return_status := FND_API.G_RET_STS_SUCCESS;

7107: p_instr_id,
7108: 'Y'
7109: );
7110:
7111: x_return_status := FND_API.G_RET_STS_SUCCESS;
7112:
7113: IF ( G_LEVEL_STATEMENT >= G_CURRENT_RUNTIME_LEVEL) THEN
7114: print_debuginfo(l_module_name, 'Returning success response ..');
7115:

Line 7133: x_return_status := FND_API.G_RET_STS_ERROR;

7129: print_debuginfo(l_module_name, 'SQLERRM: ' || SQLERRM);
7130: END IF;
7131: FND_MSG_PUB.add_exc_msg(G_PKG_NAME, l_module_name, null);
7132:
7133: x_return_status := FND_API.G_RET_STS_ERROR;
7134:
7135: IF ( G_LEVEL_STATEMENT >= G_CURRENT_RUNTIME_LEVEL) THEN
7136: print_debuginfo(l_module_name, 'EXIT');
7137:

Line 7260: x_return_status := FND_API.G_RET_STS_SUCCESS;

7256: p_instr_id,
7257: 'N'
7258: );
7259:
7260: x_return_status := FND_API.G_RET_STS_SUCCESS;
7261:
7262: IF ( G_LEVEL_STATEMENT >= G_CURRENT_RUNTIME_LEVEL) THEN
7263: print_debuginfo(l_module_name, 'Returning success response ..');
7264:

Line 7282: x_return_status := FND_API.G_RET_STS_ERROR;

7278: print_debuginfo(l_module_name, 'SQLERRM: ' || SQLERRM);
7279: END IF;
7280: FND_MSG_PUB.add_exc_msg(G_PKG_NAME, l_module_name, null);
7281:
7282: x_return_status := FND_API.G_RET_STS_ERROR;
7283:
7284: IF ( G_LEVEL_STATEMENT >= G_CURRENT_RUNTIME_LEVEL) THEN
7285: print_debuginfo(l_module_name, 'EXIT');
7286:

Line 7464: | FND_API.G_RET_STS_SUCCESS indicates that the

7460: | the payments.
7461: |
7462: | OUT
7463: | x_return_status - Result of the API call:
7464: | FND_API.G_RET_STS_SUCCESS indicates that the
7465: | finalization process completed raised
7466: | successfully. In this case the caller must
7467: | COMMIT the status change.
7468: |

Line 7469: | FND_API.G_RET_STS_ERROR (or other) indicates

7465: | finalization process completed raised
7466: | successfully. In this case the caller must
7467: | COMMIT the status change.
7468: |
7469: | FND_API.G_RET_STS_ERROR (or other) indicates
7470: | that API did not complete successfully.
7471: | In this case, the caller must issue a
7472: | ROLLBACK to undo all status changes.
7473: |

Line 7551: | FND_API.G_RET_STS_SUCCESS indicates that the

7547: | the payments.
7548: |
7549: | OUT
7550: | x_return_status - Result of the API call:
7551: | FND_API.G_RET_STS_SUCCESS indicates that the
7552: | finalization process completed raised
7553: | successfully. In this case the caller must
7554: | COMMIT the status change.
7555: |

Line 7556: | FND_API.G_RET_STS_ERROR (or other) indicates

7552: | finalization process completed raised
7553: | successfully. In this case the caller must
7554: | COMMIT the status change.
7555: |
7556: | FND_API.G_RET_STS_ERROR (or other) indicates
7557: | that API did not complete successfully.
7558: | In this case, the caller must issue a
7559: | ROLLBACK to undo all status changes.
7560: |

Line 7662: | FND_API.G_RET_STS_SUCCESS indicates that the

7658: | the payments.
7659: |
7660: | OUT
7661: | x_return_status - Result of the API call:
7662: | FND_API.G_RET_STS_SUCCESS indicates that the
7663: | finalization process completed raised
7664: | successfully. In this case the caller must
7665: | COMMIT the status change.
7666: |

Line 7667: | FND_API.G_RET_STS_ERROR (or other) indicates

7663: | finalization process completed raised
7664: | successfully. In this case the caller must
7665: | COMMIT the status change.
7666: |
7667: | FND_API.G_RET_STS_ERROR (or other) indicates
7668: | that API did not complete successfully.
7669: | In this case, the caller must issue a
7670: | ROLLBACK to undo all status changes.
7671: |

Line 7756: | FND_API.G_RET_STS_SUCCESS indicates that the

7752: | the payments.
7753: |
7754: | OUT
7755: | x_return_status - Result of the API call:
7756: | FND_API.G_RET_STS_SUCCESS indicates that the
7757: | finalization process completed raised
7758: | successfully. In this case the caller must
7759: | COMMIT the status change.
7760: |

Line 7761: | FND_API.G_RET_STS_ERROR (or other) indicates

7757: | finalization process completed raised
7758: | successfully. In this case the caller must
7759: | COMMIT the status change.
7760: |
7761: | FND_API.G_RET_STS_ERROR (or other) indicates
7762: | that API did not complete successfully.
7763: | In this case, the caller must issue a
7764: | ROLLBACK to undo all status changes.
7765: |

Line 7862: IF x_return_status <> FND_API.G_RET_STS_SUCCESS THEN

7858: 'PAYMENT_INSTRUCTION',
7859: x_return_status
7860: );
7861:
7862: IF x_return_status <> FND_API.G_RET_STS_SUCCESS THEN
7863: RAISE FND_API.G_EXC_ERROR;
7864: ELSE
7865: IF ( G_LEVEL_STATEMENT >= G_CURRENT_RUNTIME_LEVEL) THEN
7866: print_debuginfo(l_module_name, 'unlock_pmt_entity() API returned success');

Line 7863: RAISE FND_API.G_EXC_ERROR;

7859: x_return_status
7860: );
7861:
7862: IF x_return_status <> FND_API.G_RET_STS_SUCCESS THEN
7863: RAISE FND_API.G_EXC_ERROR;
7864: ELSE
7865: IF ( G_LEVEL_STATEMENT >= G_CURRENT_RUNTIME_LEVEL) THEN
7866: print_debuginfo(l_module_name, 'unlock_pmt_entity() API returned success');
7867: END IF;

Line 7911: IF x_return_status <> FND_API.G_RET_STS_SUCCESS THEN

7907: p_conc_request_id => l_request_id,
7908: x_return_status => x_return_status
7909: );
7910:
7911: IF x_return_status <> FND_API.G_RET_STS_SUCCESS THEN
7912: RAISE FND_API.G_EXC_ERROR;
7913: ELSE
7914:
7915: IF ( G_LEVEL_STATEMENT >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 7912: RAISE FND_API.G_EXC_ERROR;

7908: x_return_status => x_return_status
7909: );
7910:
7911: IF x_return_status <> FND_API.G_RET_STS_SUCCESS THEN
7912: RAISE FND_API.G_EXC_ERROR;
7913: ELSE
7914:
7915: IF ( G_LEVEL_STATEMENT >= G_CURRENT_RUNTIME_LEVEL) THEN
7916: print_debuginfo(l_module_name, 'lock_pmt_entity() API returned success');

Line 8309: -- l_return_status := FND_API.G_RET_STS_ERROR;

8305: -- || '. Returning failure response .. '
8306: -- );
8307: --
8308: -- END IF;
8309: -- l_return_status := FND_API.G_RET_STS_ERROR;
8310: --
8311: -- IF ( G_LEVEL_STATEMENT >= G_CURRENT_RUNTIME_LEVEL) THEN
8312: -- print_debuginfo(l_module_name, 'EXIT');
8313: -- END IF;

Line 8490: IF (x_return_status_remove_doc <> FND_API.G_RET_STS_SUCCESS) THEN

8486: || 'remove_documents_payable');
8487:
8488:
8489: END IF;
8490: IF (x_return_status_remove_doc <> FND_API.G_RET_STS_SUCCESS) THEN
8491:
8492: /*
8493: * Even if a single call to remove a document
8494: * failed, return failure for the entire

Line 8573: IN FND_API.G_FALSE,

8569: USING
8570: IN p_instr_id,
8571: IN 'SPOILED',
8572: IN l_api_version,
8573: IN FND_API.G_FALSE,
8574: IN FND_API.G_FALSE,
8575: OUT l_return_status,
8576: OUT l_msg_count,
8577: OUT l_msg_data

Line 8574: IN FND_API.G_FALSE,

8570: IN p_instr_id,
8571: IN 'SPOILED',
8572: IN l_api_version,
8573: IN FND_API.G_FALSE,
8574: IN FND_API.G_FALSE,
8575: OUT l_return_status,
8576: OUT l_msg_count,
8577: OUT l_msg_data
8578: ;

Line 8589: l_return_status <> FND_API.G_RET_STS_SUCCESS) THEN

8585: * If the called procedure did not return success,
8586: * raise an exception.
8587: */
8588: IF (l_return_status IS NULL OR
8589: l_return_status <> FND_API.G_RET_STS_SUCCESS) THEN
8590:
8591:
8592: print_debuginfo(l_module_name, 'Fatal: External app callout '''
8593: || l_callout_name

Line 8682: l_return_status <> FND_API.G_RET_STS_SUCCESS) THEN

8678: l_return_status
8679: );
8680:
8681: IF (l_return_status IS NULL OR
8682: l_return_status <> FND_API.G_RET_STS_SUCCESS) THEN
8683:
8684: IF ( G_LEVEL_STATEMENT >= G_CURRENT_RUNTIME_LEVEL) THEN
8685: print_debuginfo(l_module_name, 'Error status '
8686: || l_return_status

Line 8695: l_return_status := FND_API.G_RET_STS_ERROR;

8691: END IF;
8692:
8693:
8694: IF(p_used_docs_list IS NOT NULL) THEN
8695: l_return_status := FND_API.G_RET_STS_ERROR;
8696:
8697: IF ( G_LEVEL_STATEMENT >= G_CURRENT_RUNTIME_LEVEL) THEN
8698: print_debuginfo(l_module_name, 'EXIT');
8699:

Line 8735: l_return_status := FND_API.G_RET_STS_SUCCESS;

8731: || 'instruction status to PRINTED.'
8732: );
8733:
8734: END IF;
8735: l_return_status := FND_API.G_RET_STS_SUCCESS;
8736: COMMIT;
8737: /*
8738: * The payment instruction was possibly locked
8739: * by the UI. Unlock it if possible.

Line 8773: l_return_status := FND_API.G_RET_STS_ERROR;

8769: print_debuginfo(l_module_name, 'SQLERRM: ' || SQLERRM);
8770: END IF;
8771: FND_MSG_PUB.add_exc_msg(G_PKG_NAME, l_module_name, null);
8772:
8773: l_return_status := FND_API.G_RET_STS_ERROR;
8774: ROLLBACK;
8775: x_errbuf := 'RECORD PRINT STATUS COMPLETED IN ERRORS';
8776: x_retcode := '-1';
8777: /*

Line 8873: | FND_API.G_RET_STS_SUCCESS indicates that

8869: | the payments complete.
8870: |
8871: | OUT
8872: | x_return_status - Result of the API call:
8873: | FND_API.G_RET_STS_SUCCESS indicates that
8874: | the mark complete process finished
8875: | successfully. In this case the caller must
8876: | COMMIT the status change.
8877: |

Line 8878: | FND_API.G_RET_STS_ERROR (or other) indicates

8874: | the mark complete process finished
8875: | successfully. In this case the caller must
8876: | COMMIT the status change.
8877: |
8878: | FND_API.G_RET_STS_ERROR (or other) indicates
8879: | that API did not complete successfully.
8880: | In this case, the caller must issue a
8881: | ROLLBACK to undo all status changes.
8882: |

Line 9172: x_return_status := FND_API.G_RET_STS_SUCCESS;

9168: || 'for this instruction.'
9169: );
9170:
9171: END IF;
9172: x_return_status := FND_API.G_RET_STS_SUCCESS;
9173: IF ( G_LEVEL_STATEMENT >= G_CURRENT_RUNTIME_LEVEL) THEN
9174: print_debuginfo(l_module_name, 'Returning success response ..');
9175:
9176: print_debuginfo(l_module_name, 'EXIT');

Line 9591: IN FND_API.G_FALSE,

9587: EXECUTE IMMEDIATE
9588: (l_stmt)
9589: USING
9590: IN l_api_version,
9591: IN FND_API.G_FALSE,
9592: IN FND_API.G_FALSE,
9593: OUT x_return_status,
9594: OUT l_msg_count,
9595: OUT l_msg_data,

Line 9592: IN FND_API.G_FALSE,

9588: (l_stmt)
9589: USING
9590: IN l_api_version,
9591: IN FND_API.G_FALSE,
9592: IN FND_API.G_FALSE,
9593: OUT x_return_status,
9594: OUT l_msg_count,
9595: OUT l_msg_data,
9596: IN l_completion_id

Line 9609: x_return_status <> FND_API.G_RET_STS_SUCCESS) THEN

9605: * If the called procedure did not return success,
9606: * raise an exception.
9607: */
9608: IF (x_return_status IS NULL OR
9609: x_return_status <> FND_API.G_RET_STS_SUCCESS) THEN
9610:
9611:
9612: print_debuginfo(l_module_name, 'Fatal: External app '
9613: || 'callout '''

Line 10202: x_return_status := FND_API.G_RET_STS_SUCCESS;

10198: END IF;
10199:
10200: END IF;
10201:
10202: x_return_status := FND_API.G_RET_STS_SUCCESS;
10203:
10204: IF ( G_LEVEL_STATEMENT >= G_CURRENT_RUNTIME_LEVEL) THEN
10205: print_debuginfo(l_module_name, 'Returning success response ..');
10206:

Line 10225: x_return_status := FND_API.G_RET_STS_ERROR;

10221: print_debuginfo(l_module_name, 'SQLERRM: ' || SQLERRM);
10222: --END IF; Bug 14335525
10223: -- FND_MSG_PUB.add_exc_msg(G_PKG_NAME, l_module_name, null);
10224:
10225: x_return_status := FND_API.G_RET_STS_ERROR;
10226:
10227: IF ( G_LEVEL_STATEMENT >= G_CURRENT_RUNTIME_LEVEL) THEN
10228: print_debuginfo(l_module_name, 'EXIT');
10229:

Line 10273: x_return_status := FND_API.G_RET_STS_SUCCESS;

10269: print_debuginfo(l_module_name, 'ENTER');
10270: END IF;
10271: FND_MSG_PUB.initialize;
10272:
10273: x_return_status := FND_API.G_RET_STS_SUCCESS;
10274:
10275: -- Update payment transaction statuses (instruction, payments, etc.)
10276: IBY_FD_POST_PICP_PROGS_PVT.Post_Results(
10277: p_instr_id,

Line 10296: x_return_status <> FND_API.G_RET_STS_SUCCESS) THEN

10292: p_error_msg);
10293: end if;
10294:
10295: IF (x_return_status IS NULL OR
10296: x_return_status <> FND_API.G_RET_STS_SUCCESS) THEN
10297: IF ( G_LEVEL_STATEMENT >= G_CURRENT_RUNTIME_LEVEL) THEN
10298: print_debuginfo(l_module_name, 'Returning error response: '
10299: || x_return_status
10300: );

Line 10326: x_return_status := FND_API.G_RET_STS_ERROR;

10322: print_debuginfo(l_module_name, 'SQLERRM: ' || SQLERRM);
10323: END IF;
10324: FND_MSG_PUB.add_exc_msg(G_PKG_NAME, l_module_name, null);
10325:
10326: x_return_status := FND_API.G_RET_STS_ERROR;
10327:
10328: IF ( G_LEVEL_STATEMENT >= G_CURRENT_RUNTIME_LEVEL) THEN
10329: print_debuginfo(l_module_name, 'EXIT');
10330:

Line 10897: x_return_status <> FND_API.G_RET_STS_SUCCESS) THEN

10893: l_msg_data
10894: );
10895:
10896: IF (x_return_status IS NULL OR
10897: x_return_status <> FND_API.G_RET_STS_SUCCESS) THEN
10898:
10899:
10900: print_debuginfo(l_module_name, 'Check numbering '
10901: || 'operation failed for payment instruction '

Line 10973: x_return_status := FND_API.G_RET_STS_SUCCESS;

10969: */
10970: IF ( G_LEVEL_STATEMENT >= G_CURRENT_RUNTIME_LEVEL) THEN
10971: print_debuginfo(l_module_name, 'Returning success response ..');
10972: END IF;
10973: x_return_status := FND_API.G_RET_STS_SUCCESS;
10974:
10975: IF ( G_LEVEL_STATEMENT >= G_CURRENT_RUNTIME_LEVEL) THEN
10976: print_debuginfo(l_module_name, 'EXIT');
10977:

Line 11003: x_return_status := FND_API.G_RET_STS_ERROR;

10999: /*
11000: * The error message would have already been set.
11001: * Just set the error status here.
11002: */
11003: x_return_status := FND_API.G_RET_STS_ERROR;
11004:
11005: IF ( G_LEVEL_STATEMENT >= G_CURRENT_RUNTIME_LEVEL) THEN
11006: print_debuginfo(l_module_name, 'EXIT');
11007:

Line 11244: x_return_status := FND_API.G_RET_STS_SUCCESS;

11240: )
11241: ;
11242: END IF;
11243:
11244: x_return_status := FND_API.G_RET_STS_SUCCESS;
11245: IF ( G_LEVEL_STATEMENT >= G_CURRENT_RUNTIME_LEVEL) THEN
11246: print_debuginfo(l_module_name, 'EXIT');
11247:
11248: END IF;

Line 11268: x_return_status := FND_API.G_RET_STS_ERROR;

11264: print_debuginfo(l_module_name, 'SQLERRM: ' || SQLERRM);
11265:
11266: END IF;
11267: FND_MSG_PUB.add_exc_msg(G_PKG_NAME, l_module_name, null);
11268: x_return_status := FND_API.G_RET_STS_ERROR;
11269:
11270: IF ( G_LEVEL_STATEMENT >= G_CURRENT_RUNTIME_LEVEL) THEN
11271: print_debuginfo(l_module_name, 'EXIT');
11272:

Line 11490: x_return_status <> FND_API.G_RET_STS_SUCCESS) THEN

11486:
11487:
11488: END IF;
11489: IF (x_return_status IS NULL OR
11490: x_return_status <> FND_API.G_RET_STS_SUCCESS) THEN
11491:
11492: IF ( G_LEVEL_STATEMENT >= G_CURRENT_RUNTIME_LEVEL) THEN
11493: print_debuginfo(l_module_name, 'Audit of conc request '
11494: || l_conc_request_id

Line 11519: x_return_status := FND_API.G_RET_STS_SUCCESS;

11515: * with a concurrent request id.
11516: */
11517: COMMIT;
11518:
11519: x_return_status := FND_API.G_RET_STS_SUCCESS;
11520: IF ( G_LEVEL_STATEMENT >= G_CURRENT_RUNTIME_LEVEL) THEN
11521: print_debuginfo(l_module_name, 'Returning success response ..');
11522:
11523: print_debuginfo(l_module_name, 'EXIT');

Line 11541: x_return_status := FND_API.G_RET_STS_ERROR;

11537: FND_MSG_PUB.add_exc_msg(G_PKG_NAME, l_module_name, null);
11538:
11539: ROLLBACK;
11540:
11541: x_return_status := FND_API.G_RET_STS_ERROR;
11542:
11543: IF ( G_LEVEL_STATEMENT >= G_CURRENT_RUNTIME_LEVEL) THEN
11544: print_debuginfo(l_module_name, 'EXIT');
11545:

Line 11669: x_return_status := FND_API.G_RET_STS_SUCCESS;

11665: * with a concurrent request id.
11666: */
11667: COMMIT;
11668:
11669: x_return_status := FND_API.G_RET_STS_SUCCESS;
11670: IF ( G_LEVEL_STATEMENT >= G_CURRENT_RUNTIME_LEVEL) THEN
11671: print_debuginfo(l_module_name, 'Returning success response ..');
11672:
11673: print_debuginfo(l_module_name, 'EXIT');

Line 11691: x_return_status := FND_API.G_RET_STS_ERROR;

11687: FND_MSG_PUB.add_exc_msg(G_PKG_NAME, l_module_name, null);
11688:
11689: ROLLBACK;
11690:
11691: x_return_status := FND_API.G_RET_STS_ERROR;
11692:
11693: IF ( G_LEVEL_STATEMENT >= G_CURRENT_RUNTIME_LEVEL) THEN
11694: print_debuginfo(l_module_name, 'EXIT');
11695:

Line 11753: x_return_status := FND_API.G_RET_STS_SUCCESS;

11749: null;
11750: end;
11751:
11752: if(l_count<>0) then
11753: x_return_status := FND_API.G_RET_STS_SUCCESS;
11754: return;
11755: end if;
11756:
11757: OPEN c_pay_function;

Line 11780: x_return_status := FND_API.G_RET_STS_SUCCESS;

11776: end if;
11777: end loop;
11778: close c_pay_function;
11779:
11780: x_return_status := FND_API.G_RET_STS_SUCCESS;
11781: return;
11782: EXCEPTION
11783:
11784: WHEN OTHERS THEN

Line 11796: x_return_status := FND_API.G_RET_STS_ERROR;

11792: /*
11793: * The error message would have already been set.
11794: * Just set the error status here.
11795: */
11796: x_return_status := FND_API.G_RET_STS_ERROR;
11797:
11798: IF ( G_LEVEL_STATEMENT >= G_CURRENT_RUNTIME_LEVEL) THEN
11799: print_debuginfo(l_module_name, 'EXIT');
11800:

Line 11909: x_return_status := FND_API.G_RET_STS_SUCCESS;

11905: populatePaymentFunctions(x_return_status, x_return_message);
11906: x_access_flag:='N';
11907:
11908: /* Initialize return status */
11909: x_return_status := FND_API.G_RET_STS_SUCCESS;
11910:
11911: select count(1)
11912: into l_function_count
11913: from iby_process_functions pfun

Line 11956: x_return_status := FND_API.G_RET_STS_ERROR;

11952:
11953: FND_MESSAGE.set_name('IBY', l_message_code);
11954: FND_MSG_PUB.add;
11955:
11956: x_return_status := FND_API.G_RET_STS_ERROR;
11957:
11958: FND_MSG_PUB.Count_And_Get(
11959: p_encoded => FND_API.G_FALSE,
11960: p_count => l_msg_count,

Line 11959: p_encoded => FND_API.G_FALSE,

11955:
11956: x_return_status := FND_API.G_RET_STS_ERROR;
11957:
11958: FND_MSG_PUB.Count_And_Get(
11959: p_encoded => FND_API.G_FALSE,
11960: p_count => l_msg_count,
11961: p_data => x_return_message
11962: );
11963:

Line 11985: x_return_status := FND_API.G_RET_STS_ERROR;

11981: /*
11982: * The error message would have already been set.
11983: * Just set the error status here.
11984: */
11985: x_return_status := FND_API.G_RET_STS_ERROR;
11986:
11987: IF ( G_LEVEL_STATEMENT >= G_CURRENT_RUNTIME_LEVEL) THEN
11988: print_debuginfo(l_module_name, 'EXIT');
11989: END IF;

Line 12456: x_return_status := FND_API.G_RET_STS_ERROR;

12452: print_debuginfo(l_module_name, 'SQLCODE: ' || SQLCODE);
12453: print_debuginfo(l_module_name, 'SQLERRM: ' || SQLERRM);
12454:
12455: END IF;
12456: x_return_status := FND_API.G_RET_STS_ERROR;
12457:
12458: IF ( G_LEVEL_STATEMENT >= G_CURRENT_RUNTIME_LEVEL) THEN
12459: print_debuginfo(l_module_name, 'Returning error status: '
12460: || x_return_status

Line 12826: x_return_status := FND_API.G_RET_STS_SUCCESS;

12822: IF ( G_LEVEL_STATEMENT >= G_CURRENT_RUNTIME_LEVEL) THEN
12823: print_debuginfo(l_module_name, 'ENTER');
12824:
12825: END IF;
12826: x_return_status := FND_API.G_RET_STS_SUCCESS;
12827: FND_MSG_PUB.initialize;
12828:
12829: /* set the context for the request set IBY_SECURITY_MASKING_REQ_SET */
12830: l_success := fnd_submit.set_request_set('IBY', 'IBY_SECURITY_MASKING_REQ_SET');

Line 12869: x_return_status := FND_API.G_RET_STS_ERROR;

12865: raise submit_failed;
12866: end if;
12867: EXCEPTION
12868: WHEN submit_failed THEN
12869: x_return_status := FND_API.G_RET_STS_ERROR;
12870: IF ( G_LEVEL_STATEMENT >= G_CURRENT_RUNTIME_LEVEL) THEN
12871: print_debuginfo(l_module_name, 'Exception submit_failed - ' || l_phase);
12872: END IF;
12873: FND_MSG_PUB.add_exc_msg(G_PKG_NAME, l_module_name, null);

Line 12876: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;

12872: END IF;
12873: FND_MSG_PUB.add_exc_msg(G_PKG_NAME, l_module_name, null);
12874:
12875: WHEN others THEN
12876: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
12877: IF ( G_LEVEL_STATEMENT >= G_CURRENT_RUNTIME_LEVEL) THEN
12878: print_debuginfo(l_module_name, 'Exception others.');
12879: print_debuginfo(l_module_name, 'SQL code: ' || SQLCODE);
12880: print_debuginfo(l_module_name, 'SQL err msg: '|| SQLERRM);

Line 12927: x_return_status := FND_API.G_RET_STS_SUCCESS;

12923: IF ( G_LEVEL_STATEMENT >= G_CURRENT_RUNTIME_LEVEL) THEN
12924: print_debuginfo(l_module_name, 'ENTER');
12925:
12926: END IF;
12927: x_return_status := FND_API.G_RET_STS_SUCCESS;
12928: FND_MSG_PUB.initialize;
12929:
12930: /* set the context for the request set IBY_SECURITY_DECRYPT_REQ_SET */
12931: l_success := fnd_submit.set_request_set('IBY', 'IBY_SECURITY_DECRYPT_REQ_SET');

Line 12994: x_return_status := FND_API.G_RET_STS_ERROR;

12990: raise submit_failed;
12991: end if;
12992: EXCEPTION
12993: WHEN submit_failed THEN
12994: x_return_status := FND_API.G_RET_STS_ERROR;
12995: IF ( G_LEVEL_STATEMENT >= G_CURRENT_RUNTIME_LEVEL) THEN
12996: print_debuginfo(l_module_name, 'Exception submit_failed - ' || l_phase);
12997: END IF;
12998: FND_MSG_PUB.add_exc_msg(G_PKG_NAME, l_module_name, null);

Line 13001: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;

12997: END IF;
12998: FND_MSG_PUB.add_exc_msg(G_PKG_NAME, l_module_name, null);
12999:
13000: WHEN others THEN
13001: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
13002: IF ( G_LEVEL_STATEMENT >= G_CURRENT_RUNTIME_LEVEL) THEN
13003: print_debuginfo(l_module_name, 'Exception others.');
13004: print_debuginfo(l_module_name, 'SQL code: ' || SQLCODE);
13005: print_debuginfo(l_module_name, 'SQL err msg: '|| SQLERRM);

Line 13016: | Get the concurrent request id status using the FND API.

13012: | NAME:
13013: | get_conc_request_status
13014: |
13015: | PURPOSE:
13016: | Get the concurrent request id status using the FND API.
13017: |
13018: | PARAMETERS:
13019: | IN x_request_id
13020: |

Line 13046: -- call FND API to get request status

13042:
13043: BEGIN
13044: IF (x_request_id IS NOT NULL) THEN
13045: v_request_id := x_request_id;
13046: -- call FND API to get request status
13047: v_call_status := FND_CONCURRENT.get_request_status(
13048: v_request_id,
13049: null, null,
13050: v_req_phase_t, v_req_status_t,

Line 13383: x_return_status := FND_API.G_RET_STS_SUCCESS;

13379:
13380: populatePaymentFunctions(x_return_status, x_return_message);
13381:
13382: /* Initialize return status */
13383: x_return_status := FND_API.G_RET_STS_SUCCESS;
13384:
13385: select count(1)
13386: into l_doc_function_count
13387: FROM IBY_DOCS_PAYABLE_ALL docs

Line 13488: x_return_status := FND_API.G_RET_STS_ERROR;

13484: /*
13485: * The error message would have already been set.
13486: * Just set the error status here.
13487: */
13488: x_return_status := FND_API.G_RET_STS_ERROR;
13489:
13490: IF ( G_LEVEL_STATEMENT >= G_CURRENT_RUNTIME_LEVEL) THEN
13491: print_debuginfo(l_module_name, 'EXIT');
13492:

Line 13630: p_init_msg_list => FND_API.G_TRUE,

13626:
13627: x_default_bank_acct_id := null;
13628: IBY_DISBURSEMENT_COMP_PUB.Get_Applicable_Payee_Acc_list
13629: (p_api_version => 1.0,
13630: p_init_msg_list => FND_API.G_TRUE,
13631: p_trxn_attributes_rec => l_trxn_attributes_rec,
13632: x_return_status => l_return_status,
13633: x_msg_count => l_msg_count,
13634: x_msg_data => l_msg_data,