APPS.IBY_DISBURSE_UI_API_PUB_PKG dependencies on FND_API

Line 127: | FND_API.G_RET_STS_SUCCESS indicates that a

123: | p_request_date
124: |
125: | OUT
126: | x_return_status - Result of the API call:
127: | FND_API.G_RET_STS_SUCCESS indicates that a
128: | callout was invoked successfully.
129: | In this case the caller must COMMIT
130: | the status change.
131: |

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

128: | callout was invoked successfully.
129: | In this case the caller must COMMIT
130: | the status change.
131: |
132: | FND_API.G_RET_STS_UNEXP_ERROR (or other) indicates
133: | that API did not complete successfully.
134: | In this case, the caller must issue a
135: | ROLLBACK to undo all status changes.
136: | x_msg_count

Line 174: x_return_status := FND_API.G_RET_STS_SUCCESS;

170:
171: WHERE
172: PAYMENT_ID = p_payment_id;
173:
174: x_return_status := FND_API.G_RET_STS_SUCCESS;
175: print_debuginfo(l_module_name, 'EXIT');
176:
177: EXCEPTION
178: WHEN OTHERS THEN

Line 179: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;

175: print_debuginfo(l_module_name, 'EXIT');
176:
177: EXCEPTION
178: WHEN OTHERS THEN
179: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
180: x_msg_count := 1;
181: x_msg_data := substr(SQLERRM,1,25);
182:
183: print_debuginfo(l_module_name, 'EXIT');

Line 206: | FND_API.G_RET_STS_SUCCESS indicates that a

202: | p_release_reference
203: | p_release_date
204: |
205: | OUT x_return_status - Result of the API call:
206: | FND_API.G_RET_STS_SUCCESS indicates that a
207: | callout was invoked successfully.
208: | In this case the caller must COMMIT
209: | the status change.
210: |

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

207: | callout was invoked successfully.
208: | In this case the caller must COMMIT
209: | the status change.
210: |
211: | FND_API.G_RET_STS_UNEXP_ERROR (or other) indicates
212: | that API did not complete successfully.
213: | In this case, the caller must issue a
214: | ROLLBACK to undo all status changes.
215: | x_msg_count

Line 247: x_return_status := FND_API.G_RET_STS_SUCCESS;

243:
244: WHERE
245: PAYMENT_ID = p_payment_id;
246:
247: x_return_status := FND_API.G_RET_STS_SUCCESS;
248: print_debuginfo(l_module_name, 'EXIT');
249:
250: EXCEPTION
251: WHEN OTHERS THEN

Line 252: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;

248: print_debuginfo(l_module_name, 'EXIT');
249:
250: EXCEPTION
251: WHEN OTHERS THEN
252: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
253: x_msg_count := 1;
254: x_msg_data := substr(SQLERRM,1,25);
255:
256: print_debuginfo(l_module_name, 'EXIT');

Line 283: | FND_API.G_RET_STS_SUCCESS indicates that a

279: | be removed.
280: |
281: | OUT
282: | x_return_status - Result of the API call:
283: | FND_API.G_RET_STS_SUCCESS indicates that a
284: | callout was invoked successfully.
285: | In this case the caller must COMMIT
286: | the status change.
287: |

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

284: | callout was invoked successfully.
285: | In this case the caller must COMMIT
286: | the status change.
287: |
288: | FND_API.G_RET_STS_ERROR (or other) indicates
289: | that API did not complete successfully.
290: | In this case, the caller must issue a
291: | ROLLBACK to undo all status changes.
292: |

Line 444: IN FND_API.G_FALSE,

440: EXECUTE IMMEDIATE
441: (l_stmt)
442: USING
443: IN l_api_version,
444: IN FND_API.G_FALSE,
445: IN FND_API.G_FALSE,
446: OUT x_return_status,
447: OUT l_msg_count,
448: OUT l_msg_data,

Line 445: IN FND_API.G_FALSE,

441: (l_stmt)
442: USING
443: IN l_api_version,
444: IN FND_API.G_FALSE,
445: IN FND_API.G_FALSE,
446: OUT x_return_status,
447: OUT l_msg_count,
448: OUT l_msg_data,
449: IN l_rejection_id

Line 457: x_return_status <> FND_API.G_RET_STS_SUCCESS) THEN

453: * If the called procedure did not return success,
454: * raise an exception.
455: */
456: IF (x_return_status IS NULL OR
457: x_return_status <> FND_API.G_RET_STS_SUCCESS) THEN
458:
459: print_debuginfo(l_module_name, 'Fatal: External app callout '''
460: || l_callout_name
461: || ''', returned failure status - '

Line 496: x_return_status := FND_API.G_RET_STS_SUCCESS;

492: */
493: RAISE;
494: END;
495:
496: x_return_status := FND_API.G_RET_STS_SUCCESS;
497:
498: print_debuginfo(l_module_name, 'EXIT');
499:
500: EXCEPTION

Line 514: x_return_status := FND_API.G_RET_STS_ERROR;

510:
511: print_debuginfo(l_module_name, 'SQLCODE: ' || SQLCODE);
512: print_debuginfo(l_module_name, 'SQLERRM: ' || SQLERRM);
513: FND_MSG_PUB.add_exc_msg(G_PKG_NAME, l_module_name, null);
514: x_return_status := FND_API.G_RET_STS_ERROR;
515:
516: print_debuginfo(l_module_name, 'EXIT');
517:
518: END remove_document_payable;

Line 542: | FND_API.G_RET_STS_SUCCESS indicates that all

538: | be removed. This should be an array of statuses.
539: |
540: | OUT
541: | x_return_status - Result of the API call:
542: | FND_API.G_RET_STS_SUCCESS indicates that all
543: | callouts were invoked successfully.
544: | In this case the caller must COMMIT
545: | the status changes.
546: |

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

543: | callouts were invoked successfully.
544: | In this case the caller must COMMIT
545: | the status changes.
546: |
547: | FND_API.G_RET_STS_ERROR (or other) indicates
548: | that at least one event did not complete
549: | successfully. In this case, the caller must
550: | issue a ROLLBACK to undo all status changes.
551: |

Line 587: x_return_status := FND_API.G_RET_STS_ERROR;

583: || 'payable ids/statuses is empty'
584: || '. Returning failure response .. '
585: );
586:
587: x_return_status := FND_API.G_RET_STS_ERROR;
588:
589: print_debuginfo(l_module_name, 'EXIT');
590:
591: RETURN;

Line 603: x_return_status := FND_API.G_RET_STS_ERROR;

599: || 'statuses'
600: || '. Returning failure response .. '
601: );
602:
603: x_return_status := FND_API.G_RET_STS_ERROR;
604:
605: print_debuginfo(l_module_name, 'EXIT');
606:
607: RETURN;

Line 627: x_return_status <> FND_API.G_RET_STS_SUCCESS) THEN

623: * Check if the call to remove the document
624: * payable succeeded.
625: */
626: IF (x_return_status IS NULL OR
627: x_return_status <> FND_API.G_RET_STS_SUCCESS) THEN
628:
629: /*
630: * Even if a single call to remove a doc payable
631: * failed, return failure for the entire API request.

Line 650: x_return_status := FND_API.G_RET_STS_SUCCESS;

646: END IF;
647:
648: END LOOP;
649:
650: x_return_status := FND_API.G_RET_STS_SUCCESS;
651:
652: print_debuginfo(l_module_name, 'Returning success response ..');
653:
654: print_debuginfo(l_module_name, 'EXIT');

Line 680: | FND_API.G_RET_STS_SUCCESS indicates that

676: | be removed.
677: |
678: | OUT
679: | x_return_status - Result of the API call:
680: | FND_API.G_RET_STS_SUCCESS indicates that
681: | the callout was invoked successfully.
682: | In this case the caller must COMMIT
683: | the status changes.
684: |

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

681: | the callout was invoked successfully.
682: | In this case the caller must COMMIT
683: | the status changes.
684: |
685: | FND_API.G_RET_STS_ERROR (or other) indicates
686: | that tha API did not complete successfully.
687: | In this case, the caller must issue a
688: | ROLLBACK to undo all status changes.
689: |

Line 856: IN FND_API.G_FALSE,

852: EXECUTE IMMEDIATE
853: (l_stmt)
854: USING
855: IN l_api_version,
856: IN FND_API.G_FALSE,
857: IN FND_API.G_FALSE,
858: OUT x_return_status,
859: OUT l_msg_count,
860: OUT l_msg_data,

Line 857: IN FND_API.G_FALSE,

853: (l_stmt)
854: USING
855: IN l_api_version,
856: IN FND_API.G_FALSE,
857: IN FND_API.G_FALSE,
858: OUT x_return_status,
859: OUT l_msg_count,
860: OUT l_msg_data,
861: IN l_rejection_id

Line 869: x_return_status <> FND_API.G_RET_STS_SUCCESS) THEN

865: * If the called procedure did not return success,
866: * raise an exception.
867: */
868: IF (x_return_status IS NULL OR
869: x_return_status <> FND_API.G_RET_STS_SUCCESS) THEN
870:
871: print_debuginfo(l_module_name, 'Fatal: External app callout '''
872: || l_callout_name
873: || ''', returned failure status - '

Line 909: x_return_status := FND_API.G_RET_STS_SUCCESS;

905: RAISE;
906: END;
907:
908:
909: x_return_status := FND_API.G_RET_STS_SUCCESS;
910:
911: print_debuginfo(l_module_name, 'EXIT');
912:
913: EXCEPTION

Line 928: x_return_status := FND_API.G_RET_STS_ERROR;

924: print_debuginfo(l_module_name, 'SQLCODE: ' || SQLCODE);
925: print_debuginfo(l_module_name, 'SQLERRM: ' || SQLERRM);
926: FND_MSG_PUB.add_exc_msg(G_PKG_NAME, l_module_name, null);
927:
928: x_return_status := FND_API.G_RET_STS_ERROR;
929:
930: print_debuginfo(l_module_name, 'EXIT');
931:
932: END remove_payment;

Line 958: | FND_API.G_RET_STS_SUCCESS indicates that all

954: | be removed. This should be an array of statuses.
955: |
956: | OUT
957: | x_return_status - Result of the API call:
958: | FND_API.G_RET_STS_SUCCESS indicates that all
959: | the callouts were invoked successfully.
960: | In this case the caller must COMMIT
961: | the status changes.
962: |

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

959: | the callouts were invoked successfully.
960: | In this case the caller must COMMIT
961: | the status changes.
962: |
963: | FND_API.G_RET_STS_ERROR (or other) indicates
964: | that at least one event did not complete
965: | successfully. In this case, the caller must
966: | issue a ROLLBACK to undo all status changes.
967: |

Line 1005: x_return_status := FND_API.G_RET_STS_ERROR;

1001: || 'payable ids/statuses is empty'
1002: || '. Returning failure response .. '
1003: );
1004:
1005: x_return_status := FND_API.G_RET_STS_ERROR;
1006:
1007: print_debuginfo(l_module_name, 'EXIT');
1008:
1009: RETURN;

Line 1020: x_return_status := FND_API.G_RET_STS_ERROR;

1016: || 'ids must match list of payment statuses. '
1017: || 'Returning failure response .. '
1018: );
1019:
1020: x_return_status := FND_API.G_RET_STS_ERROR;
1021:
1022: print_debuginfo(l_module_name, 'EXIT');
1023:
1024: RETURN;

Line 1043: x_return_status <> FND_API.G_RET_STS_SUCCESS) THEN

1039: /*
1040: * Check if the call to remove the payment succeeded.
1041: */
1042: IF (x_return_status IS NULL OR
1043: x_return_status <> FND_API.G_RET_STS_SUCCESS) THEN
1044:
1045: /*
1046: * Even if a single call to remove a payment
1047: * failed, return failure for the entire API request.

Line 1066: x_return_status := FND_API.G_RET_STS_SUCCESS;

1062: END IF;
1063:
1064: END LOOP;
1065:
1066: x_return_status := FND_API.G_RET_STS_SUCCESS;
1067:
1068: print_debuginfo(l_module_name, 'Returning success response ..');
1069:
1070: print_debuginfo(l_module_name, 'EXIT');

Line 1094: | FND_API.G_RET_STS_SUCCESS indicates that all

1090: | specified payment request will be removed.
1091: |
1092: | OUT
1093: | x_return_status - Result of the API call:
1094: | FND_API.G_RET_STS_SUCCESS indicates that all
1095: | the callouts were invoked successfully.
1096: | In this case the caller must COMMIT
1097: | the status changes.
1098: |

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

1095: | the callouts were invoked successfully.
1096: | In this case the caller must COMMIT
1097: | the status changes.
1098: |
1099: | FND_API.G_RET_STS_ERROR (or other) indicates
1100: | that at least one event did not complete
1101: | successfully. In this case, the caller must
1102: | issue a ROLLBACK to undo all status changes.
1103: |

Line 1189: x_return_status <> FND_API.G_RET_STS_SUCCESS) THEN

1185: /*
1186: * Check if the call to remove the documents succeeded.
1187: */
1188: IF (x_return_status IS NULL OR
1189: x_return_status <> FND_API.G_RET_STS_SUCCESS) THEN
1190:
1191: /*
1192: * Even if a single call to remove a document
1193: * failed, return failure for the entire API request.

Line 1221: x_return_status := FND_API.G_RET_STS_SUCCESS;

1217: );
1218:
1219: END IF;
1220:
1221: x_return_status := FND_API.G_RET_STS_SUCCESS;
1222:
1223: print_debuginfo(l_module_name, 'Returning success response ..');
1224:
1225: print_debuginfo(l_module_name, 'EXIT');

Line 1251: | FND_API.G_RET_STS_SUCCESS indicates that the

1247: | be stopped.
1248: |
1249: | OUT
1250: | x_return_status - Result of the API call:
1251: | FND_API.G_RET_STS_SUCCESS indicates that the
1252: | callout was invoked successfully.
1253: | In this case the caller must COMMIT
1254: | the status changes.
1255: |

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

1252: | callout was invoked successfully.
1253: | In this case the caller must COMMIT
1254: | the status changes.
1255: |
1256: | FND_API.G_RET_STS_ERROR (or other) indicates
1257: | that tha API did not complete successfully.
1258: | In this case, the caller must issue a
1259: | ROLLBACK to undo all status changes.
1260: |

Line 1509: IN FND_API.G_FALSE,

1505: EXECUTE IMMEDIATE
1506: (l_stmt)
1507: USING
1508: IN l_api_version,
1509: IN FND_API.G_FALSE,
1510: IN FND_API.G_FALSE,
1511: OUT x_return_status,
1512: OUT l_msg_count,
1513: OUT l_msg_data,

Line 1510: IN FND_API.G_FALSE,

1506: (l_stmt)
1507: USING
1508: IN l_api_version,
1509: IN FND_API.G_FALSE,
1510: IN FND_API.G_FALSE,
1511: OUT x_return_status,
1512: OUT l_msg_count,
1513: OUT l_msg_data,
1514: IN l_rejection_id

Line 1522: x_return_status <> FND_API.G_RET_STS_SUCCESS) THEN

1518: * If the called procedure did not return success,
1519: * raise an exception.
1520: */
1521: IF (x_return_status IS NULL OR
1522: x_return_status <> FND_API.G_RET_STS_SUCCESS) THEN
1523:
1524: print_debuginfo(l_module_name, 'Fatal: External app callout '''
1525: || l_callout_name
1526: || ''', returned failure status - '

Line 1560: x_return_status := FND_API.G_RET_STS_SUCCESS;

1556: */
1557: RAISE;
1558: END;
1559:
1560: x_return_status := FND_API.G_RET_STS_SUCCESS;
1561:
1562: print_debuginfo(l_module_name, 'EXIT');
1563:
1564: EXCEPTION

Line 1579: x_return_status := FND_API.G_RET_STS_ERROR;

1575: print_debuginfo(l_module_name, 'SQLCODE: ' || SQLCODE);
1576: print_debuginfo(l_module_name, 'SQLERRM: ' || SQLERRM);
1577: FND_MSG_PUB.add_exc_msg(G_PKG_NAME, l_module_name, null);
1578:
1579: x_return_status := FND_API.G_RET_STS_ERROR;
1580:
1581: print_debuginfo(l_module_name, 'EXIT');
1582:
1583: END stop_payment;

Line 1609: | FND_API.G_RET_STS_SUCCESS indicates that all

1605: | be stopped. This should be an array of statuses.
1606: |
1607: | OUT
1608: | x_return_status - Result of the API call:
1609: | FND_API.G_RET_STS_SUCCESS indicates that all
1610: | the callouts were invoked successfully.
1611: | In this case the caller must COMMIT
1612: | the status changes.
1613: |

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

1610: | the callouts were invoked successfully.
1611: | In this case the caller must COMMIT
1612: | the status changes.
1613: |
1614: | FND_API.G_RET_STS_ERROR (or other) indicates
1615: | that at least one event did not complete
1616: | successfully. In this case, the caller must
1617: | issue a ROLLBACK to undo all status changes.
1618: |

Line 1656: x_return_status := FND_API.G_RET_STS_ERROR;

1652: || 'payable ids/statuses is empty'
1653: || '. Returning failure response .. '
1654: );
1655:
1656: x_return_status := FND_API.G_RET_STS_ERROR;
1657:
1658: print_debuginfo(l_module_name, 'EXIT');
1659:
1660: RETURN;

Line 1671: x_return_status := FND_API.G_RET_STS_ERROR;

1667: || 'ids must match list of payment statuses. '
1668: || 'Returning failure response .. '
1669: );
1670:
1671: x_return_status := FND_API.G_RET_STS_ERROR;
1672:
1673: print_debuginfo(l_module_name, 'EXIT');
1674:
1675: RETURN;

Line 1694: x_return_status <> FND_API.G_RET_STS_SUCCESS) THEN

1690: /*
1691: * Check if the call to stop the payment succeeded.
1692: */
1693: IF (x_return_status IS NULL OR
1694: x_return_status <> FND_API.G_RET_STS_SUCCESS) THEN
1695:
1696: /*
1697: * Even if a single call to stop a payment
1698: * failed, return failure for the entire API request.

Line 1717: x_return_status := FND_API.G_RET_STS_SUCCESS;

1713: END IF;
1714:
1715: END LOOP;
1716:
1717: x_return_status := FND_API.G_RET_STS_SUCCESS;
1718:
1719: print_debuginfo(l_module_name, 'Returning success response ..');
1720:
1721: print_debuginfo(l_module_name, 'EXIT');

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

1738: | PARAMETERS:
1739: | IN
1740: | p_api_version - Version of the API.
1741: |
1742: | p_init_msg_list - Standard API parameter; default as FND_API.G_FALSE
1743: |
1744: | p_pmt_id - ID of the payment to be voided. This id will map
1745: | to IBY_PAYMENTS_ALL.PAYMENT_ID column.
1746: |

Line 1757: | FND_API.G_RET_STS_SUCCESS

1753: | p_void_reason - Reason why this payment needs to be voided.
1754: |
1755: | OUT
1756: | x_return_status - Standard return status. Possible values are:
1757: | FND_API.G_RET_STS_SUCCESS
1758: | API completed successfully. Caller must
1759: | now COMMIT the database changes.
1760: |
1761: | FND_API.G_RET_STS_ERROR

Line 1761: | FND_API.G_RET_STS_ERROR

1757: | FND_API.G_RET_STS_SUCCESS
1758: | API completed successfully. Caller must
1759: | now COMMIT the database changes.
1760: |
1761: | FND_API.G_RET_STS_ERROR
1762: | API call failed. Caller must ROLLBACK any
1763: | base changes.
1764: |
1765: | x_msg_count - Standard msg count

Line 1780: p_init_msg_list IN VARCHAR2 DEFAULT FND_API.G_FALSE,

1776: |
1777: *---------------------------------------------------------------------*/
1778: PROCEDURE void_payment (
1779: p_api_version IN NUMBER,
1780: p_init_msg_list IN VARCHAR2 DEFAULT FND_API.G_FALSE,
1781: p_pmt_id IN NUMBER,
1782: p_voided_by IN NUMBER,
1783: p_void_date IN DATE,
1784: p_void_reason IN VARCHAR2,

Line 1817: IF NOT FND_API.Compatible_API_Call(

1813: || p_void_reason
1814: );
1815:
1816: /* Standard call to check for API compatibility */
1817: IF NOT FND_API.Compatible_API_Call(
1818: l_api_version,
1819: p_api_version,
1820: l_api_name,
1821: G_PKG_NAME) THEN

Line 1823: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;

1819: p_api_version,
1820: l_api_name,
1821: G_PKG_NAME) THEN
1822:
1823: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
1824:
1825: END IF;
1826:
1827: /* Initialize message list if p_init_msg_list is set to TRUE */

Line 1828: IF FND_API.to_boolean(p_init_msg_list) THEN

1824:
1825: END IF;
1826:
1827: /* Initialize message list if p_init_msg_list is set to TRUE */
1828: IF FND_API.to_boolean(p_init_msg_list) THEN
1829: FND_MSG_PUB.initialize;
1830: END IF;
1831:
1832: /* Initialize return status */

Line 1833: x_return_status := FND_API.G_RET_STS_SUCCESS;

1829: FND_MSG_PUB.initialize;
1830: END IF;
1831:
1832: /* Initialize return status */
1833: x_return_status := FND_API.G_RET_STS_SUCCESS;
1834:
1835: /*
1836: * STEP I:
1837: *

Line 2012: p_encoded => FND_API.G_FALSE,

2008: * Standard call to get message count and if count is 1, get
2009: * message info.
2010: */
2011: FND_MSG_PUB.Count_And_Get(
2012: p_encoded => FND_API.G_FALSE,
2013: p_count => x_msg_count,
2014: p_data => x_msg_data
2015: );
2016:

Line 2017: x_return_status := FND_API.G_RET_STS_SUCCESS;

2013: p_count => x_msg_count,
2014: p_data => x_msg_data
2015: );
2016:
2017: x_return_status := FND_API.G_RET_STS_SUCCESS;
2018: print_debuginfo(l_module_name, 'Returning success response ..');
2019:
2020: print_debuginfo(l_module_name, 'EXIT');
2021:

Line 2035: x_return_status := FND_API.G_RET_STS_ERROR;

2031: print_debuginfo(l_module_name, 'SQL code: ' || SQLCODE);
2032: print_debuginfo(l_module_name, 'SQL err msg: '|| SQLERRM);
2033: FND_MSG_PUB.add_exc_msg(G_PKG_NAME, l_module_name, null);
2034:
2035: x_return_status := FND_API.G_RET_STS_ERROR;
2036:
2037: FND_MSG_PUB.Count_And_Get(
2038: p_encoded => FND_API.G_FALSE,
2039: p_count => x_msg_count,

Line 2038: p_encoded => FND_API.G_FALSE,

2034:
2035: x_return_status := FND_API.G_RET_STS_ERROR;
2036:
2037: FND_MSG_PUB.Count_And_Get(
2038: p_encoded => FND_API.G_FALSE,
2039: p_count => x_msg_count,
2040: p_data => x_msg_data
2041: );
2042:

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

2062: | PARAMETERS:
2063: | IN
2064: | p_api_version - Version of the API.
2065: |
2066: | p_init_msg_list - Standard API parameter; default as FND_API.G_FALSE
2067: |
2068: | p_pmt_id - ID of the payment to be voided. This id will map
2069: | to IBY_PAYMENTS_ALL.PAYMENT_ID column.
2070: |

Line 2081: | FND_API.G_RET_STS_SUCCESS

2077: | p_void_reason - Reason why this payment needs to be voided.
2078: |
2079: | OUT
2080: | x_return_status - Standard return status. Possible values are:
2081: | FND_API.G_RET_STS_SUCCESS
2082: | API completed successfully. Caller must
2083: | now COMMIT the database changes.
2084: |
2085: | FND_API.G_RET_STS_ERROR

Line 2085: | FND_API.G_RET_STS_ERROR

2081: | FND_API.G_RET_STS_SUCCESS
2082: | API completed successfully. Caller must
2083: | now COMMIT the database changes.
2084: |
2085: | FND_API.G_RET_STS_ERROR
2086: | API call failed. Caller must ROLLBACK any
2087: | base changes.
2088: |
2089: | x_msg_count - Standard msg count

Line 2104: p_init_msg_list IN VARCHAR2 DEFAULT FND_API.G_FALSE,

2100: |
2101: *---------------------------------------------------------------------*/
2102: PROCEDURE void_pmt_internal (
2103: p_api_version IN NUMBER,
2104: p_init_msg_list IN VARCHAR2 DEFAULT FND_API.G_FALSE,
2105: p_pmt_id IN NUMBER,
2106: p_voided_by IN NUMBER,
2107: p_void_date IN DATE,
2108: p_void_reason IN VARCHAR2,

Line 2231: IF NOT FND_API.Compatible_API_Call(

2227: */
2228: /*---- end ----*/
2229:
2230: /* Standard call to check for API compatibility */
2231: IF NOT FND_API.Compatible_API_Call(
2232: l_api_version,
2233: p_api_version,
2234: l_api_name,
2235: G_PKG_NAME) THEN

Line 2237: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;

2233: p_api_version,
2234: l_api_name,
2235: G_PKG_NAME) THEN
2236:
2237: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
2238:
2239: END IF;
2240:
2241: /* Initialize message list if p_init_msg_list is set to TRUE */

Line 2242: IF FND_API.to_boolean(p_init_msg_list) THEN

2238:
2239: END IF;
2240:
2241: /* Initialize message list if p_init_msg_list is set to TRUE */
2242: IF FND_API.to_boolean(p_init_msg_list) THEN
2243: FND_MSG_PUB.initialize;
2244: END IF;
2245:
2246: /* Initialize return status */

Line 2247: x_return_status := FND_API.G_RET_STS_SUCCESS;

2243: FND_MSG_PUB.initialize;
2244: END IF;
2245:
2246: /* Initialize return status */
2247: x_return_status := FND_API.G_RET_STS_SUCCESS;
2248:
2249: /*
2250: * Fix for bug 5623941:
2251: *

Line 2280: x_return_status := FND_API.G_RET_STS_SUCCESS;

2276: || p_pmt_id
2277: || ' is already voided. Skipping .. '
2278: );
2279:
2280: x_return_status := FND_API.G_RET_STS_SUCCESS;
2281:
2282: print_debuginfo(l_module_name, 'Returning success response ..');
2283: print_debuginfo(l_module_name, 'EXIT');
2284:

Line 2298: FND_API.G_FALSE,

2294: * further.
2295: */
2296: is_void_allowed (
2297: p_api_version,
2298: FND_API.G_FALSE,
2299: p_pmt_id,
2300: l_ret_flag,
2301: x_return_status,
2302: x_msg_count,

Line 2321: x_return_status := FND_API.G_RET_STS_ERROR;

2317: print_debuginfo(l_module_name, 'Void not allowed. '
2318: || 'Returning failure response.'
2319: );
2320:
2321: x_return_status := FND_API.G_RET_STS_ERROR;
2322:
2323: FND_MSG_PUB.Count_And_Get(
2324: p_encoded => FND_API.G_FALSE,
2325: p_count => x_msg_count,

Line 2324: p_encoded => FND_API.G_FALSE,

2320:
2321: x_return_status := FND_API.G_RET_STS_ERROR;
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 2548: IN FND_API.G_FALSE,

2544: USING
2545: IN l_api_version,
2546: IN p_pmt_id,
2547: IN p_void_date,
2548: IN FND_API.G_FALSE,
2549: IN FND_API.G_FALSE, /* commit flag */
2550: OUT x_return_status,
2551: OUT l_msg_count,
2552: OUT l_msg_data

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

2545: IN l_api_version,
2546: IN p_pmt_id,
2547: IN p_void_date,
2548: IN FND_API.G_FALSE,
2549: IN FND_API.G_FALSE, /* commit flag */
2550: OUT x_return_status,
2551: OUT l_msg_count,
2552: OUT l_msg_data
2553: ;

Line 2564: x_return_status <> FND_API.G_RET_STS_SUCCESS) THEN

2560: * If the called procedure did not return success,
2561: * raise an exception.
2562: */
2563: IF (x_return_status IS NULL OR
2564: x_return_status <> FND_API.G_RET_STS_SUCCESS) THEN
2565:
2566: print_debuginfo(l_module_name, 'Fatal: External app callout '''
2567: || l_callout_name
2568: || ''', returned failure status - '

Line 2607: p_encoded => FND_API.G_FALSE,

2603: * Standard call to get message count and if count is 1, get
2604: * message info.
2605: */
2606: FND_MSG_PUB.Count_And_Get(
2607: p_encoded => FND_API.G_FALSE,
2608: p_count => x_msg_count,
2609: p_data => x_msg_data
2610: );
2611:

Line 2612: x_return_status := FND_API.G_RET_STS_SUCCESS;

2608: p_count => x_msg_count,
2609: p_data => x_msg_data
2610: );
2611:
2612: x_return_status := FND_API.G_RET_STS_SUCCESS;
2613: print_debuginfo(l_module_name, 'Returning success response ..');
2614:
2615: print_debuginfo(l_module_name, 'EXIT');
2616:

Line 2629: x_return_status := FND_API.G_RET_STS_ERROR;

2625: print_debuginfo(l_module_name, 'SQL code: ' || SQLCODE);
2626: print_debuginfo(l_module_name, 'SQL err msg: '|| SQLERRM);
2627: FND_MSG_PUB.add_exc_msg(G_PKG_NAME, l_module_name, null);
2628:
2629: x_return_status := FND_API.G_RET_STS_ERROR;
2630:
2631: FND_MSG_PUB.Count_And_Get(
2632: p_encoded => FND_API.G_FALSE,
2633: p_count => x_msg_count,

Line 2632: p_encoded => FND_API.G_FALSE,

2628:
2629: x_return_status := FND_API.G_RET_STS_ERROR;
2630:
2631: FND_MSG_PUB.Count_And_Get(
2632: p_encoded => FND_API.G_FALSE,
2633: p_count => x_msg_count,
2634: p_data => x_msg_data
2635: );
2636:

Line 2666: p_init_msg_list IN VARCHAR2 DEFAULT FND_API.G_FALSE,

2662: |
2663: *---------------------------------------------------------------------*/
2664: PROCEDURE is_void_allowed (
2665: p_api_version IN NUMBER,
2666: p_init_msg_list IN VARCHAR2 DEFAULT FND_API.G_FALSE,
2667: p_pmt_id IN NUMBER,
2668: x_return_flag OUT NOCOPY VARCHAR2, /* 'Y'/'N' flag */
2669: x_return_status OUT NOCOPY VARCHAR2,
2670: x_msg_count OUT NOCOPY NUMBER,

Line 2713: IF NOT FND_API.Compatible_API_Call(

2709:
2710: print_debuginfo(l_module_name, 'ENTER');
2711:
2712: /* Standard call to check for API compatibility */
2713: IF NOT FND_API.Compatible_API_Call(
2714: l_api_version,
2715: p_api_version,
2716: l_api_name,
2717: G_PKG_NAME) THEN

Line 2719: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;

2715: p_api_version,
2716: l_api_name,
2717: G_PKG_NAME) THEN
2718:
2719: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
2720:
2721: END IF;
2722:
2723: /* Initialize message list if p_init_msg_list is set to TRUE */

Line 2724: IF FND_API.to_boolean(p_init_msg_list) THEN

2720:
2721: END IF;
2722:
2723: /* Initialize message list if p_init_msg_list is set to TRUE */
2724: IF FND_API.to_boolean(p_init_msg_list) THEN
2725: FND_MSG_PUB.initialize;
2726: END IF;
2727:
2728: /* Initialize return status */

Line 2729: x_return_status := FND_API.G_RET_STS_SUCCESS;

2725: FND_MSG_PUB.initialize;
2726: END IF;
2727:
2728: /* Initialize return status */
2729: x_return_status := FND_API.G_RET_STS_SUCCESS;
2730:
2731: /*
2732: * Get the application name of the calling app. This
2733: * will be used in the callout.

Line 2785: IN FND_API.G_FALSE,

2781: EXECUTE IMMEDIATE
2782: (l_stmt)
2783: USING
2784: IN l_api_version,
2785: IN FND_API.G_FALSE,
2786: IN FND_API.G_FALSE,
2787: IN p_pmt_id,
2788: OUT x_return_flag,
2789: OUT x_return_status,

Line 2786: IN FND_API.G_FALSE,

2782: (l_stmt)
2783: USING
2784: IN l_api_version,
2785: IN FND_API.G_FALSE,
2786: IN FND_API.G_FALSE,
2787: IN p_pmt_id,
2788: OUT x_return_flag,
2789: OUT x_return_status,
2790: OUT l_msg_count,

Line 2799: x_return_status <> FND_API.G_RET_STS_SUCCESS) THEN

2795: * If the called procedure did not return success,
2796: * raise an exception.
2797: */
2798: IF (x_return_status IS NULL OR
2799: x_return_status <> FND_API.G_RET_STS_SUCCESS) THEN
2800:
2801: print_debuginfo(l_module_name, 'Fatal: External app callout '''
2802: || l_callout_name
2803: || ''', returned failure status - '

Line 2854: x_return_status := FND_API.G_RET_STS_SUCCESS;

2850: */
2851: RAISE;
2852: END;
2853:
2854: x_return_status := FND_API.G_RET_STS_SUCCESS;
2855:
2856: print_debuginfo(l_module_name, 'EXIT');
2857:
2858: EXCEPTION

Line 2871: x_return_status := FND_API.G_RET_STS_ERROR;

2867: print_debuginfo(l_module_name, 'SQLCODE: ' || SQLCODE);
2868: print_debuginfo(l_module_name, 'SQLERRM: ' || SQLERRM);
2869: FND_MSG_PUB.add_exc_msg(G_PKG_NAME, l_module_name, null);
2870:
2871: x_return_status := FND_API.G_RET_STS_ERROR;
2872:
2873: print_debuginfo(l_module_name, 'EXIT');
2874:
2875: END is_void_allowed;

Line 2909: | FND_API.G_RET_STS_SUCCESS indicates that all

2905: | p_void_reason - Reason why this payment needs to be voided.
2906: |
2907: | OUT
2908: | x_return_status - Result of the API call:
2909: | FND_API.G_RET_STS_SUCCESS indicates that all
2910: | the callouts were invoked successfully.
2911: | In this case the caller must COMMIT
2912: | the status changes.
2913: |

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

2910: | the callouts were invoked successfully.
2911: | In this case the caller must COMMIT
2912: | the status changes.
2913: |
2914: | FND_API.G_RET_STS_ERROR (or other) indicates
2915: | that at least one event did not complete
2916: | successfully. In this case, the caller must
2917: | issue a ROLLBACK to undo all status changes.
2918: |

Line 2985: x_return_status := FND_API.G_RET_STS_ERROR;

2981: || ' were found for payment instruction id '
2982: || p_instr_id
2983: );
2984:
2985: x_return_status := FND_API.G_RET_STS_ERROR;
2986:
2987: print_debuginfo(l_module_name, 'EXIT');
2988:
2989: RETURN;

Line 3000: FND_API.G_FALSE,

2996: FOR i IN l_pmts_list.FIRST .. l_pmts_list.LAST LOOP
2997:
2998: void_pmt_internal (
2999: l_api_version,
3000: FND_API.G_FALSE,
3001: l_pmts_list(i),
3002: p_voided_by,
3003: p_void_date,
3004: p_void_reason,

Line 3014: x_return_status <> FND_API.G_RET_STS_SUCCESS) THEN

3010: /*
3011: * Check if the call to stop the payment succeeded.
3012: */
3013: IF (x_return_status IS NULL OR
3014: x_return_status <> FND_API.G_RET_STS_SUCCESS) THEN
3015:
3016: /*
3017: * Even if a single call to remove a payment
3018: * failed, return failure for the entire API request.

Line 3069: x_return_status := FND_API.G_RET_STS_SUCCESS;

3065: || p_instr_id
3066: || ' set to TERMINATED because all payments have been voided.'
3067: );
3068:
3069: x_return_status := FND_API.G_RET_STS_SUCCESS;
3070:
3071: print_debuginfo(l_module_name, 'Returning success response ..');
3072:
3073: print_debuginfo(l_module_name, 'EXIT');

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

3085: | PARAMETERS:
3086: | IN
3087: | p_api_version - Version of the API.
3088: |
3089: | p_init_msg_list - Standard API parameter; default as FND_API.G_FALSE
3090: |
3091: | p_payment_doc_id
3092: | - ID of the payment document (check stock) to use.
3093: |

Line 3103: | FND_API.G_RET_STS_SUCCESS

3099: | returned as an output parameter.
3100: |
3101: | OUT
3102: | x_return_status - Standard return status. Possible values are:
3103: | FND_API.G_RET_STS_SUCCESS
3104: | The given paper document number is valid
3105: | for the given payment document.
3106: |
3107: | It is possible that there were warnings.

Line 3112: | FND_API.G_RET_STS_ERROR

3108: | Please unwind the FND message stack to
3109: | check if there were any warnings to display
3110: | to the user.
3111: |
3112: | FND_API.G_RET_STS_ERROR
3113: | The given paper document number is invalid.
3114: | Possible reasons are the paper document number
3115: | has already been used, or the paper document
3116: | number is not in the valid range for the given

Line 3134: p_init_msg_list IN VARCHAR2 DEFAULT FND_API.G_FALSE,

3130: |
3131: *---------------------------------------------------------------------*/
3132: PROCEDURE validate_paper_doc_number (
3133: p_api_version IN NUMBER,
3134: p_init_msg_list IN VARCHAR2 DEFAULT FND_API.G_FALSE,
3135: p_payment_doc_id IN NUMBER,
3136: x_paper_doc_num IN OUT NOCOPY NUMBER,
3137: x_return_status OUT NOCOPY VARCHAR2,
3138: x_msg_count OUT NOCOPY NUMBER,

Line 3140: show_warn_msgs_flag IN VARCHAR2 DEFAULT FND_API.G_TRUE

3136: x_paper_doc_num IN OUT NOCOPY NUMBER,
3137: x_return_status OUT NOCOPY VARCHAR2,
3138: x_msg_count OUT NOCOPY NUMBER,
3139: x_msg_data OUT NOCOPY VARCHAR2,
3140: show_warn_msgs_flag IN VARCHAR2 DEFAULT FND_API.G_TRUE
3141: )
3142: IS
3143:
3144: l_module_name CONSTANT VARCHAR2(200) := G_PKG_NAME

Line 3167: IF NOT FND_API.Compatible_API_Call(

3163:
3164: print_debuginfo(l_module_name, 'ENTER');
3165:
3166: /* Standard call to check for API compatibility */
3167: IF NOT FND_API.Compatible_API_Call(
3168: l_api_version,
3169: p_api_version,
3170: l_api_name,
3171: G_PKG_NAME) THEN

Line 3173: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;

3169: p_api_version,
3170: l_api_name,
3171: G_PKG_NAME) THEN
3172:
3173: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
3174:
3175: END IF;
3176:
3177: /* Initialize message list if p_init_msg_list is set to TRUE */

Line 3178: IF FND_API.to_boolean(p_init_msg_list) THEN

3174:
3175: END IF;
3176:
3177: /* Initialize message list if p_init_msg_list is set to TRUE */
3178: IF FND_API.to_boolean(p_init_msg_list) THEN
3179: FND_MSG_PUB.initialize;
3180: END IF;
3181:
3182: /* Initialize return status */

Line 3183: x_return_status := FND_API.G_RET_STS_SUCCESS;

3179: FND_MSG_PUB.initialize;
3180: END IF;
3181:
3182: /* Initialize return status */
3183: x_return_status := FND_API.G_RET_STS_SUCCESS;
3184:
3185:
3186: /*
3187: * Pull up the details of the paper stock, like the

Line 3223: x_return_status := FND_API.G_RET_STS_ERROR;

3219: print_debuginfo(l_module_name, 'SQL code: ' || SQLCODE);
3220: print_debuginfo(l_module_name, 'SQL err msg: '|| SQLERRM);
3221: FND_MSG_PUB.add_exc_msg(G_PKG_NAME, l_module_name, null);
3222:
3223: x_return_status := FND_API.G_RET_STS_ERROR;
3224:
3225: l_error_code := 'IBY_INS_NO_PMT_DOC';
3226: FND_MESSAGE.set_name('IBY', l_error_code);
3227:

Line 3256: x_return_status := FND_API.G_RET_STS_ERROR;

3252:
3253: print_debuginfo(l_module_name, 'SQL code: ' || SQLCODE);
3254: print_debuginfo(l_module_name, 'SQL err msg: '|| SQLERRM);
3255:
3256: x_return_status := FND_API.G_RET_STS_ERROR;
3257:
3258: l_error_code := 'IBY_PMT_DOC_EXCEPTION';
3259: FND_MESSAGE.set_name('IBY', l_error_code);
3260:

Line 3352: x_return_status := FND_API.G_RET_STS_ERROR;

3348: || ' is exhausted. No more paper documents are '
3349: || 'available for issue.'
3350: );
3351:
3352: x_return_status := FND_API.G_RET_STS_ERROR;
3353:
3354: l_error_code := 'IBY_CHECK_STOCK_EXHAUSTED';
3355: FND_MESSAGE.set_name('IBY', l_error_code);
3356:

Line 3389: x_return_status := FND_API.G_RET_STS_SUCCESS;

3385: x_paper_doc_num := -1;
3386:
3387: ELSE
3388:
3389: x_return_status := FND_API.G_RET_STS_SUCCESS;
3390:
3391: print_debuginfo(l_module_name, 'Generated paper document '
3392: || 'number '
3393: || x_paper_doc_num

Line 3429: x_return_status := FND_API.G_RET_STS_ERROR;

3425: || ' is below first available document number '
3426: || l_first_avail_check_num
3427: );
3428:
3429: x_return_status := FND_API.G_RET_STS_ERROR;
3430:
3431: l_error_code := 'IBY_DOC_NUM_BELOW_ALLOWED';
3432: FND_MESSAGE.set_name('IBY', l_error_code);
3433:

Line 3480: x_return_status := FND_API.G_RET_STS_ERROR;

3476: || ' is above last available document number '
3477: || l_last_avail_check_num
3478: );
3479:
3480: x_return_status := FND_API.G_RET_STS_ERROR;
3481:
3482: l_error_code := 'IBY_DOC_NUM_ABOVE_ALLOWED';
3483: FND_MESSAGE.set_name('IBY', l_error_code);
3484:

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

3520: * By setting the show warnings flag to 'false' for
3521: * the single payments flow, the number of potential
3522: * messages displayed to the user is reduced.
3523: */
3524: IF (show_warn_msgs_flag = FND_API.G_TRUE) THEN
3525:
3526: print_debuginfo(l_module_name, 'Warning: Provided paper '
3527: || 'doc number '
3528: || x_paper_doc_num

Line 3561: x_return_status := FND_API.G_RET_STS_ERROR;

3557: || x_paper_doc_num
3558: || ' has already been used.'
3559: );
3560:
3561: x_return_status := FND_API.G_RET_STS_ERROR;
3562:
3563: l_error_code := 'IBY_DOC_NUM_USED';
3564: FND_MESSAGE.set_name('IBY', l_error_code);
3565:

Line 3595: x_return_status := FND_API.G_RET_STS_SUCCESS;

3591: * number and the payment document id are valid.
3592: */
3593: print_debuginfo(l_module_name, 'Returning success response ..');
3594:
3595: x_return_status := FND_API.G_RET_STS_SUCCESS;
3596:
3597: print_debuginfo(l_module_name, 'EXIT');
3598:
3599: END validate_paper_doc_number;

Line 3781: x_return_status := FND_API.G_RET_STS_ERROR;

3777: || ' has been locked by a concurrent program.'
3778: || ' It cannot be terminated at present.'
3779: );
3780:
3781: x_return_status := FND_API.G_RET_STS_ERROR;
3782:
3783: l_error_code := 'IBY_INS_LOCKED';
3784: FND_MESSAGE.set_name('IBY', l_error_code);
3785: FND_MSG_PUB.ADD;

Line 4191: IN FND_API.G_FALSE,

4187: EXECUTE IMMEDIATE
4188: (l_stmt)
4189: USING
4190: IN l_api_version,
4191: IN FND_API.G_FALSE,
4192: IN FND_API.G_FALSE,
4193: OUT x_return_status,
4194: OUT l_msg_count,
4195: OUT l_msg_data,

Line 4192: IN FND_API.G_FALSE,

4188: (l_stmt)
4189: USING
4190: IN l_api_version,
4191: IN FND_API.G_FALSE,
4192: IN FND_API.G_FALSE,
4193: OUT x_return_status,
4194: OUT l_msg_count,
4195: OUT l_msg_data,
4196: IN l_rejection_id

Line 4204: x_return_status <> FND_API.G_RET_STS_SUCCESS) THEN

4200: * If the called procedure did not return success,
4201: * raise an exception.
4202: */
4203: IF (x_return_status IS NULL OR
4204: x_return_status <> FND_API.G_RET_STS_SUCCESS) THEN
4205:
4206: print_debuginfo(l_module_name, 'Fatal: External app callout '''
4207: || l_callout_name
4208: || ''', returned failure status - '

Line 4272: x_return_status := FND_API.G_RET_STS_SUCCESS;

4268: 'PAYMENT_INSTRUCTION',
4269: l_ret_status
4270: );
4271:
4272: x_return_status := FND_API.G_RET_STS_SUCCESS;
4273:
4274: print_debuginfo(l_module_name, 'EXIT');
4275:
4276: EXCEPTION

Line 4291: x_return_status := FND_API.G_RET_STS_ERROR;

4287: print_debuginfo(l_module_name, 'SQLCODE: ' || SQLCODE);
4288: print_debuginfo(l_module_name, 'SQLERRM: ' || SQLERRM);
4289: FND_MSG_PUB.add_exc_msg(G_PKG_NAME, l_module_name, null);
4290:
4291: x_return_status := FND_API.G_RET_STS_ERROR;
4292:
4293: print_debuginfo(l_module_name, 'EXIT');
4294:
4295: END terminate_pmt_instruction;

Line 4412: x_return_status := FND_API.G_RET_STS_ERROR;

4408: || ' has been locked by a concurrent program.'
4409: || ' It cannot be terminated at present.'
4410: );
4411:
4412: x_return_status := FND_API.G_RET_STS_ERROR;
4413:
4414: l_error_code := 'IBY_PPR_LOCKED';
4415: FND_MESSAGE.set_name('IBY', l_error_code);
4416: FND_MSG_PUB.ADD;

Line 4456: x_return_status := FND_API.G_RET_STS_ERROR;

4452: || 'part of a payment instruction. Payment '
4453: || 'request cannot be terminated at this stage.'
4454: );
4455:
4456: x_return_status := FND_API.G_RET_STS_ERROR;
4457:
4458: l_error_code := 'IBY_PPR_TERM_NOT_ALLOWED';
4459: FND_MESSAGE.set_name('IBY', l_error_code);
4460: FND_MSG_PUB.ADD;

Line 4597: x_return_status := FND_API.G_RET_STS_SUCCESS;

4593: * it is not worth proceeding further.
4594: *
4595: * Return success status to the caller.
4596: */
4597: x_return_status := FND_API.G_RET_STS_SUCCESS;
4598:
4599: print_debuginfo(l_module_name, 'EXIT');
4600: RETURN;
4601:

Line 4708: IN FND_API.G_FALSE,

4704: EXECUTE IMMEDIATE
4705: (l_stmt)
4706: USING
4707: IN l_api_version,
4708: IN FND_API.G_FALSE,
4709: IN FND_API.G_FALSE,
4710: OUT x_return_status,
4711: OUT l_msg_count,
4712: OUT l_msg_data,

Line 4709: IN FND_API.G_FALSE,

4705: (l_stmt)
4706: USING
4707: IN l_api_version,
4708: IN FND_API.G_FALSE,
4709: IN FND_API.G_FALSE,
4710: OUT x_return_status,
4711: OUT l_msg_count,
4712: OUT l_msg_data,
4713: IN l_rejection_id

Line 4726: x_return_status <> FND_API.G_RET_STS_SUCCESS) THEN

4722: * If the called procedure did not return success,
4723: * raise an exception.
4724: */
4725: IF (x_return_status IS NULL OR
4726: x_return_status <> FND_API.G_RET_STS_SUCCESS) THEN
4727:
4728: print_debuginfo(l_module_name, 'Fatal: External app callout '''
4729: || l_callout_name
4730: || ''', returned failure status - '

Line 4792: x_return_status := FND_API.G_RET_STS_SUCCESS;

4788: 'PAYMENT_REQUEST',
4789: l_ret_status
4790: );
4791:
4792: x_return_status := FND_API.G_RET_STS_SUCCESS;
4793:
4794: print_debuginfo(l_module_name, 'EXIT');
4795:
4796: EXCEPTION

Line 4811: x_return_status := FND_API.G_RET_STS_ERROR;

4807: print_debuginfo(l_module_name, 'SQLCODE: ' || SQLCODE);
4808: print_debuginfo(l_module_name, 'SQLERRM: ' || SQLERRM);
4809: FND_MSG_PUB.add_exc_msg(G_PKG_NAME, l_module_name, null);
4810:
4811: x_return_status := FND_API.G_RET_STS_ERROR;
4812:
4813: print_debuginfo(l_module_name, 'EXIT');
4814:
4815: END terminate_pmt_request;

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

5014:
5015: /*
5016: * If we are unable to lock the payment request, abort.
5017: */
5018: IF (l_ret_status <> FND_API.G_RET_STS_SUCCESS) THEN
5019:
5020: print_debuginfo(l_module_name, 'Unable to lock payment '
5021: || 'process request: '
5022: || p_payreq_id

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

5170: x_conc_req_id,
5171: l_str_ret_status
5172: );
5173:
5174: IF (l_str_ret_status <> FND_API.G_RET_STS_SUCCESS) THEN
5175:
5176: print_debuginfo(l_module_name, 'Unable to lock payment '
5177: || 'instruction: '
5178: || p_ins_id

Line 5262: | FND_API.G_RET_STS_SUCCESS indicates that the

5258: |
5259: |
5260: | OUT
5261: | x_return_status - Result of the API call:
5262: | FND_API.G_RET_STS_SUCCESS indicates that the
5263: | reprint process was triggered successfully.
5264: | In this case the caller must COMMIT
5265: | the status change.
5266: |

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

5263: | reprint process was triggered successfully.
5264: | In this case the caller must COMMIT
5265: | the status change.
5266: |
5267: | FND_API.G_RET_STS_ERROR (or other) indicates
5268: | that API did not complete successfully.
5269: | In this case, the caller must issue a
5270: | ROLLBACK to undo all status changes.
5271: |

Line 5353: x_return_status := FND_API.G_RET_STS_ERROR;

5349: || 'ids is empty'
5350: || '. Returning failure response .. '
5351: );
5352:
5353: x_return_status := FND_API.G_RET_STS_ERROR;
5354:
5355: print_debuginfo(l_module_name, 'EXIT');
5356:
5357: RETURN;

Line 5369: x_return_status := FND_API.G_RET_STS_ERROR;

5365: || 'doc numbers must match list of payment ids. '
5366: || 'Returning failure response .. '
5367: );
5368:
5369: x_return_status := FND_API.G_RET_STS_ERROR;
5370:
5371: print_debuginfo(l_module_name, 'EXIT');
5372:
5373: RETURN;

Line 5603: IN FND_API.G_FALSE,

5599: USING
5600: IN p_instr_id,
5601: IN 'REPRINT',
5602: IN l_api_version,
5603: IN FND_API.G_FALSE,
5604: IN FND_API.G_FALSE,
5605: OUT x_return_status,
5606: OUT l_msg_count,
5607: OUT l_msg_data

Line 5604: IN FND_API.G_FALSE,

5600: IN p_instr_id,
5601: IN 'REPRINT',
5602: IN l_api_version,
5603: IN FND_API.G_FALSE,
5604: IN FND_API.G_FALSE,
5605: OUT x_return_status,
5606: OUT l_msg_count,
5607: OUT l_msg_data
5608: ;

Line 5615: x_return_status <> FND_API.G_RET_STS_SUCCESS) THEN

5611: * If the called procedure did not return success,
5612: * raise an exception.
5613: */
5614: IF (x_return_status IS NULL OR
5615: x_return_status <> FND_API.G_RET_STS_SUCCESS) THEN
5616:
5617: print_debuginfo(l_module_name, 'Fatal: External app callout '''
5618: || l_callout_name
5619: || ''', returned failure status - '

Line 5667: x_return_status := FND_API.G_RET_STS_SUCCESS;

5663: p_instr_id,
5664: 'Y'
5665: );
5666:
5667: x_return_status := FND_API.G_RET_STS_SUCCESS;
5668:
5669: print_debuginfo(l_module_name, 'Returning success response ..');
5670:
5671: print_debuginfo(l_module_name, 'EXIT');

Line 5685: x_return_status := FND_API.G_RET_STS_ERROR;

5681: print_debuginfo(l_module_name, 'SQLCODE: ' || SQLCODE);
5682: print_debuginfo(l_module_name, 'SQLERRM: ' || SQLERRM);
5683: FND_MSG_PUB.add_exc_msg(G_PKG_NAME, l_module_name, null);
5684:
5685: x_return_status := FND_API.G_RET_STS_ERROR;
5686:
5687: print_debuginfo(l_module_name, 'EXIT');
5688:
5689: END reprint_prenum_pmt_documents;

Line 5729: | FND_API.G_RET_STS_SUCCESS indicates that the

5725: |
5726: |
5727: | OUT
5728: | x_return_status - Result of the API call:
5729: | FND_API.G_RET_STS_SUCCESS indicates that the
5730: | reprint process was triggered successfully.
5731: | In this case the caller must COMMIT
5732: | the status change.
5733: |

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

5730: | reprint process was triggered successfully.
5731: | In this case the caller must COMMIT
5732: | the status change.
5733: |
5734: | FND_API.G_RET_STS_ERROR (or other) indicates
5735: | that API did not complete successfully.
5736: | In this case, the caller must issue a
5737: | ROLLBACK to undo all status changes.
5738: |

Line 5799: x_return_status := FND_API.G_RET_STS_ERROR;

5795: || 'is empty'
5796: || '. Returning failure response .. '
5797: );
5798:
5799: x_return_status := FND_API.G_RET_STS_ERROR;
5800:
5801: print_debuginfo(l_module_name, 'EXIT');
5802:
5803: RETURN;

Line 5870: x_return_status := FND_API.G_RET_STS_SUCCESS;

5866: p_instr_id,
5867: 'Y'
5868: );
5869:
5870: x_return_status := FND_API.G_RET_STS_SUCCESS;
5871:
5872: print_debuginfo(l_module_name, 'Returning success response ..');
5873:
5874: print_debuginfo(l_module_name, 'EXIT');

Line 5888: x_return_status := FND_API.G_RET_STS_ERROR;

5884: print_debuginfo(l_module_name, 'SQLCODE: ' || SQLCODE);
5885: print_debuginfo(l_module_name, 'SQLERRM: ' || SQLERRM);
5886: FND_MSG_PUB.add_exc_msg(G_PKG_NAME, l_module_name, null);
5887:
5888: x_return_status := FND_API.G_RET_STS_ERROR;
5889:
5890: print_debuginfo(l_module_name, 'EXIT');
5891:
5892: END reprint_blank_pmt_documents;

Line 6006: x_return_status := FND_API.G_RET_STS_SUCCESS;

6002: p_instr_id,
6003: 'N'
6004: );
6005:
6006: x_return_status := FND_API.G_RET_STS_SUCCESS;
6007:
6008: print_debuginfo(l_module_name, 'Returning success response ..');
6009:
6010: print_debuginfo(l_module_name, 'EXIT');

Line 6024: x_return_status := FND_API.G_RET_STS_ERROR;

6020: print_debuginfo(l_module_name, 'SQLCODE: ' || SQLCODE);
6021: print_debuginfo(l_module_name, 'SQLERRM: ' || SQLERRM);
6022: FND_MSG_PUB.add_exc_msg(G_PKG_NAME, l_module_name, null);
6023:
6024: x_return_status := FND_API.G_RET_STS_ERROR;
6025:
6026: print_debuginfo(l_module_name, 'EXIT');
6027:
6028: END reprint_payment_instruction;

Line 6163: | FND_API.G_RET_STS_SUCCESS indicates that the

6159: | the payments.
6160: |
6161: | OUT
6162: | x_return_status - Result of the API call:
6163: | FND_API.G_RET_STS_SUCCESS indicates that the
6164: | finalization process completed raised
6165: | successfully. In this case the caller must
6166: | COMMIT the status change.
6167: |

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

6164: | finalization process completed raised
6165: | successfully. In this case the caller must
6166: | COMMIT the status change.
6167: |
6168: | FND_API.G_RET_STS_ERROR (or other) indicates
6169: | that API did not complete successfully.
6170: | In this case, the caller must issue a
6171: | ROLLBACK to undo all status changes.
6172: |

Line 6267: x_return_status := FND_API.G_RET_STS_ERROR;

6263: || 'document numbers is empty'
6264: || '. Returning failure response .. '
6265: );
6266:
6267: x_return_status := FND_API.G_RET_STS_ERROR;
6268:
6269: print_debuginfo(l_module_name, 'EXIT');
6270:
6271: RETURN;

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

6365: print_debuginfo(l_module_name,'Inside loop,after callling'
6366: || 'remove_documents_payable');
6367:
6368:
6369: IF (x_return_status_remove_doc <> FND_API.G_RET_STS_SUCCESS) THEN
6370:
6371: /*
6372: * Even if a single call to remove a document
6373: * failed, return failure for the entire

Line 6439: IN FND_API.G_FALSE,

6435: USING
6436: IN p_instr_id,
6437: IN 'SPOILED',
6438: IN l_api_version,
6439: IN FND_API.G_FALSE,
6440: IN FND_API.G_FALSE,
6441: OUT x_return_status,
6442: OUT l_msg_count,
6443: OUT l_msg_data

Line 6440: IN FND_API.G_FALSE,

6436: IN p_instr_id,
6437: IN 'SPOILED',
6438: IN l_api_version,
6439: IN FND_API.G_FALSE,
6440: IN FND_API.G_FALSE,
6441: OUT x_return_status,
6442: OUT l_msg_count,
6443: OUT l_msg_data
6444: ;

Line 6451: x_return_status <> FND_API.G_RET_STS_SUCCESS) THEN

6447: * If the called procedure did not return success,
6448: * raise an exception.
6449: */
6450: IF (x_return_status IS NULL OR
6451: x_return_status <> FND_API.G_RET_STS_SUCCESS) THEN
6452:
6453: print_debuginfo(l_module_name, 'Fatal: External app callout '''
6454: || l_callout_name
6455: || ''', returned failure status - '

Line 6536: x_return_status <> FND_API.G_RET_STS_SUCCESS) THEN

6532: x_return_status
6533: );
6534:
6535: IF (x_return_status IS NULL OR
6536: x_return_status <> FND_API.G_RET_STS_SUCCESS) THEN
6537:
6538: print_debuginfo(l_module_name, 'Error status '
6539: || x_return_status
6540: || ' was received from the mark_all_pmts_complete() '

Line 6571: x_return_status := FND_API.G_RET_STS_SUCCESS;

6567: print_debuginfo(l_module_name, 'Successfully set payment '
6568: || 'instruction status to PRINTED.'
6569: );
6570:
6571: x_return_status := FND_API.G_RET_STS_SUCCESS;
6572:
6573: print_debuginfo(l_module_name, 'Returning success response ..');
6574:
6575: print_debuginfo(l_module_name, 'EXIT');

Line 6589: x_return_status := FND_API.G_RET_STS_ERROR;

6585: print_debuginfo(l_module_name, 'SQLCODE: ' || SQLCODE);
6586: print_debuginfo(l_module_name, 'SQLERRM: ' || SQLERRM);
6587: FND_MSG_PUB.add_exc_msg(G_PKG_NAME, l_module_name, null);
6588:
6589: x_return_status := FND_API.G_RET_STS_ERROR;
6590:
6591: print_debuginfo(l_module_name, 'EXIT');
6592:
6593: END finalize_print_status;

Line 6640: | FND_API.G_RET_STS_SUCCESS indicates that the

6636: | the payments.
6637: |
6638: | OUT
6639: | x_return_status - Result of the API call:
6640: | FND_API.G_RET_STS_SUCCESS indicates that the
6641: | finalization process completed raised
6642: | successfully. In this case the caller must
6643: | COMMIT the status change.
6644: |

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

6641: | finalization process completed raised
6642: | successfully. In this case the caller must
6643: | COMMIT the status change.
6644: |
6645: | FND_API.G_RET_STS_ERROR (or other) indicates
6646: | that API did not complete successfully.
6647: | In this case, the caller must issue a
6648: | ROLLBACK to undo all status changes.
6649: |

Line 6748: x_return_status := FND_API.G_RET_STS_ERROR;

6744: || 'document numbers is empty'
6745: || '. Returning failure response .. '
6746: );
6747:
6748: x_return_status := FND_API.G_RET_STS_ERROR;
6749:
6750: print_debuginfo(l_module_name, 'EXIT');
6751:
6752: RETURN;

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

6962: print_debuginfo(l_module_name,'Inside loop,after callling'
6963: || 'remove_documents_payable');
6964:
6965:
6966: IF (x_return_status_remove_doc <> FND_API.G_RET_STS_SUCCESS) THEN
6967:
6968: /*
6969: * Even if a single call to remove a document
6970: * failed, return failure for the entire

Line 7038: IN FND_API.G_FALSE,

7034: USING
7035: IN p_instr_id,
7036: IN 'SPOILED',
7037: IN l_api_version,
7038: IN FND_API.G_FALSE,
7039: IN FND_API.G_FALSE,
7040: OUT x_return_status,
7041: OUT l_msg_count,
7042: OUT l_msg_data

Line 7039: IN FND_API.G_FALSE,

7035: IN p_instr_id,
7036: IN 'SPOILED',
7037: IN l_api_version,
7038: IN FND_API.G_FALSE,
7039: IN FND_API.G_FALSE,
7040: OUT x_return_status,
7041: OUT l_msg_count,
7042: OUT l_msg_data
7043: ;

Line 7050: x_return_status <> FND_API.G_RET_STS_SUCCESS) THEN

7046: * If the called procedure did not return success,
7047: * raise an exception.
7048: */
7049: IF (x_return_status IS NULL OR
7050: x_return_status <> FND_API.G_RET_STS_SUCCESS) THEN
7051:
7052: print_debuginfo(l_module_name, 'Fatal: External app callout '''
7053: || l_callout_name
7054: || ''', returned failure status - '

Line 7135: x_return_status <> FND_API.G_RET_STS_SUCCESS) THEN

7131: x_return_status
7132: );
7133:
7134: IF (x_return_status IS NULL OR
7135: x_return_status <> FND_API.G_RET_STS_SUCCESS) THEN
7136:
7137: print_debuginfo(l_module_name, 'Error status '
7138: || x_return_status
7139: || ' was received from the mark_all_pmts_complete() '

Line 7170: x_return_status := FND_API.G_RET_STS_SUCCESS;

7166: print_debuginfo(l_module_name, 'Successfully set payment '
7167: || 'instruction status to PRINTED.'
7168: );
7169:
7170: x_return_status := FND_API.G_RET_STS_SUCCESS;
7171:
7172: print_debuginfo(l_module_name, 'Returning success response ..');
7173:
7174: print_debuginfo(l_module_name, 'EXIT');

Line 7188: x_return_status := FND_API.G_RET_STS_ERROR;

7184: print_debuginfo(l_module_name, 'SQLCODE: ' || SQLCODE);
7185: print_debuginfo(l_module_name, 'SQLERRM: ' || SQLERRM);
7186: FND_MSG_PUB.add_exc_msg(G_PKG_NAME, l_module_name, null);
7187:
7188: x_return_status := FND_API.G_RET_STS_ERROR;
7189:
7190: print_debuginfo(l_module_name, 'EXIT');
7191:
7192: END finalize_print_status;

Line 7265: | FND_API.G_RET_STS_SUCCESS indicates that the

7261: | the payments.
7262: |
7263: | OUT
7264: | x_return_status - Result of the API call:
7265: | FND_API.G_RET_STS_SUCCESS indicates that the
7266: | finalization process completed raised
7267: | successfully. In this case the caller must
7268: | COMMIT the status change.
7269: |

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

7266: | finalization process completed raised
7267: | successfully. In this case the caller must
7268: | COMMIT the status change.
7269: |
7270: | FND_API.G_RET_STS_ERROR (or other) indicates
7271: | that API did not complete successfully.
7272: | In this case, the caller must issue a
7273: | ROLLBACK to undo all status changes.
7274: |

Line 7374: x_return_status := FND_API.G_RET_STS_ERROR;

7370: || ' is zero. '
7371: || 'Returning failure response .. '
7372: );
7373:
7374: x_return_status := FND_API.G_RET_STS_ERROR;
7375:
7376: print_debuginfo(l_module_name, 'EXIT');
7377:
7378: RETURN;

Line 7408: x_return_status := FND_API.G_RET_STS_ERROR;

7404: || p_instr_id
7405: || '. Returning failure response .. '
7406: );
7407:
7408: x_return_status := FND_API.G_RET_STS_ERROR;
7409:
7410: print_debuginfo(l_module_name, 'EXIT');
7411:
7412: RETURN;

Line 7525: x_return_status <> FND_API.G_RET_STS_SUCCESS) THEN

7521: || 'complete API ..'
7522: );
7523:
7524: IF (x_return_status IS NULL OR
7525: x_return_status <> FND_API.G_RET_STS_SUCCESS) THEN
7526:
7527: print_debuginfo(l_module_name, 'Error: Could not mark '
7528: || 'the payments associated with payment instruction '
7529: || p_instr_id

Line 7533: x_return_status := FND_API.G_RET_STS_ERROR;

7529: || p_instr_id
7530: || ' as complete. Returning failure response .. '
7531: );
7532:
7533: x_return_status := FND_API.G_RET_STS_ERROR;
7534:
7535: print_debuginfo(l_module_name, 'EXIT');
7536:
7537: RETURN;

Line 7567: x_return_status := FND_API.G_RET_STS_SUCCESS;

7563: || 'instruction status to PRINTED.'
7564: );
7565:
7566:
7567: x_return_status := FND_API.G_RET_STS_SUCCESS;
7568:
7569: print_debuginfo(l_module_name, 'Returning success response ..');
7570:
7571: print_debuginfo(l_module_name, 'EXIT');

Line 7586: x_return_status := FND_API.G_RET_STS_ERROR;

7582: print_debuginfo(l_module_name, 'SQLCODE: ' || SQLCODE);
7583: print_debuginfo(l_module_name, 'SQLERRM: ' || SQLERRM);
7584: FND_MSG_PUB.add_exc_msg(G_PKG_NAME, l_module_name, null);
7585:
7586: x_return_status := FND_API.G_RET_STS_ERROR;
7587:
7588: print_debuginfo(l_module_name, 'EXIT');
7589:
7590: END finalize_instr_print_status;

Line 7672: | FND_API.G_RET_STS_SUCCESS indicates that

7668: | the payments complete.
7669: |
7670: | OUT
7671: | x_return_status - Result of the API call:
7672: | FND_API.G_RET_STS_SUCCESS indicates that
7673: | the mark complete process finished
7674: | successfully. In this case the caller must
7675: | COMMIT the status change.
7676: |

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

7673: | the mark complete process finished
7674: | successfully. In this case the caller must
7675: | COMMIT the status change.
7676: |
7677: | FND_API.G_RET_STS_ERROR (or other) indicates
7678: | that API did not complete successfully.
7679: | In this case, the caller must issue a
7680: | ROLLBACK to undo all status changes.
7681: |

Line 7883: x_return_status := FND_API.G_RET_STS_SUCCESS;

7879: || ' because payments already marked complete '
7880: || 'for this instruction.'
7881: );
7882:
7883: x_return_status := FND_API.G_RET_STS_SUCCESS;
7884: print_debuginfo(l_module_name, 'Returning success response ..');
7885:
7886: print_debuginfo(l_module_name, 'EXIT');
7887:

Line 8257: IN FND_API.G_FALSE,

8253: EXECUTE IMMEDIATE
8254: (l_stmt)
8255: USING
8256: IN l_api_version,
8257: IN FND_API.G_FALSE,
8258: IN FND_API.G_FALSE,
8259: OUT x_return_status,
8260: OUT l_msg_count,
8261: OUT l_msg_data,

Line 8258: IN FND_API.G_FALSE,

8254: (l_stmt)
8255: USING
8256: IN l_api_version,
8257: IN FND_API.G_FALSE,
8258: IN FND_API.G_FALSE,
8259: OUT x_return_status,
8260: OUT l_msg_count,
8261: OUT l_msg_data,
8262: IN l_completion_id

Line 8271: x_return_status <> FND_API.G_RET_STS_SUCCESS) THEN

8267: * If the called procedure did not return success,
8268: * raise an exception.
8269: */
8270: IF (x_return_status IS NULL OR
8271: x_return_status <> FND_API.G_RET_STS_SUCCESS) THEN
8272:
8273: print_debuginfo(l_module_name, 'Fatal: External app '
8274: || 'callout '''
8275: || l_callout_name

Line 8705: x_return_status := FND_API.G_RET_STS_SUCCESS;

8701: END IF;
8702:
8703: END IF;
8704:
8705: x_return_status := FND_API.G_RET_STS_SUCCESS;
8706:
8707: print_debuginfo(l_module_name, 'Returning success response ..');
8708:
8709: print_debuginfo(l_module_name, 'EXIT');

Line 8724: x_return_status := FND_API.G_RET_STS_ERROR;

8720: print_debuginfo(l_module_name, 'SQLCODE: ' || SQLCODE);
8721: print_debuginfo(l_module_name, 'SQLERRM: ' || SQLERRM);
8722: FND_MSG_PUB.add_exc_msg(G_PKG_NAME, l_module_name, null);
8723:
8724: x_return_status := FND_API.G_RET_STS_ERROR;
8725:
8726: print_debuginfo(l_module_name, 'EXIT');
8727:
8728: END mark_all_pmts_complete;

Line 8768: x_return_status := FND_API.G_RET_STS_SUCCESS;

8764:
8765: print_debuginfo(l_module_name, 'ENTER');
8766: FND_MSG_PUB.initialize;
8767:
8768: x_return_status := FND_API.G_RET_STS_SUCCESS;
8769:
8770: -- Update payment transaction statuses (instruction, payments, etc.)
8771: IBY_FD_POST_PICP_PROGS_PVT.Post_Results(
8772: p_instr_id,

Line 8789: x_return_status <> FND_API.G_RET_STS_SUCCESS) THEN

8785: p_error_msg);
8786: end if;
8787:
8788: IF (x_return_status IS NULL OR
8789: x_return_status <> FND_API.G_RET_STS_SUCCESS) THEN
8790: print_debuginfo(l_module_name, 'Returning error response: '
8791: || x_return_status
8792: );
8793: ELSE

Line 8811: x_return_status := FND_API.G_RET_STS_ERROR;

8807: print_debuginfo(l_module_name, 'SQLCODE: ' || SQLCODE);
8808: print_debuginfo(l_module_name, 'SQLERRM: ' || SQLERRM);
8809: FND_MSG_PUB.add_exc_msg(G_PKG_NAME, l_module_name, null);
8810:
8811: x_return_status := FND_API.G_RET_STS_ERROR;
8812:
8813: print_debuginfo(l_module_name, 'EXIT');
8814:
8815: END transmit_pmt_instruction;

Line 9354: x_return_status <> FND_API.G_RET_STS_SUCCESS) THEN

9350: l_msg_data
9351: );
9352:
9353: IF (x_return_status IS NULL OR
9354: x_return_status <> FND_API.G_RET_STS_SUCCESS) THEN
9355:
9356: print_debuginfo(l_module_name, 'Check numbering '
9357: || 'operation failed for payment instruction '
9358: || p_instruction_id

Line 9418: x_return_status := FND_API.G_RET_STS_SUCCESS;

9414: /*
9415: * Return success.
9416: */
9417: print_debuginfo(l_module_name, 'Returning success response ..');
9418: x_return_status := FND_API.G_RET_STS_SUCCESS;
9419:
9420: print_debuginfo(l_module_name, 'EXIT');
9421:
9422: EXCEPTION

Line 9442: x_return_status := FND_API.G_RET_STS_ERROR;

9438: /*
9439: * The error message would have already been set.
9440: * Just set the error status here.
9441: */
9442: x_return_status := FND_API.G_RET_STS_ERROR;
9443:
9444: print_debuginfo(l_module_name, 'EXIT');
9445:
9446: END perform_check_print;

Line 9638: x_return_status := FND_API.G_RET_STS_SUCCESS;

9634: 1 /* 10 */
9635: )
9636: ;
9637:
9638: x_return_status := FND_API.G_RET_STS_SUCCESS;
9639: print_debuginfo(l_module_name, 'EXIT');
9640:
9641: EXCEPTION
9642: WHEN OTHERS THEN

Line 9658: x_return_status := FND_API.G_RET_STS_ERROR;

9654: print_debuginfo(l_module_name, 'SQLCODE: ' || SQLCODE);
9655: print_debuginfo(l_module_name, 'SQLERRM: ' || SQLERRM);
9656:
9657: FND_MSG_PUB.add_exc_msg(G_PKG_NAME, l_module_name, null);
9658: x_return_status := FND_API.G_RET_STS_ERROR;
9659:
9660: print_debuginfo(l_module_name, 'EXIT');
9661:
9662: END insert_conc_request;

Line 9828: x_return_status <> FND_API.G_RET_STS_SUCCESS) THEN

9824: );
9825:
9826:
9827: IF (x_return_status IS NULL OR
9828: x_return_status <> FND_API.G_RET_STS_SUCCESS) THEN
9829:
9830: print_debuginfo(l_module_name, 'Audit of conc request '
9831: || l_conc_request_id
9832: || ' failed. Returning error response .. '

Line 9853: x_return_status := FND_API.G_RET_STS_SUCCESS;

9849: * with a concurrent request id.
9850: */
9851: COMMIT;
9852:
9853: x_return_status := FND_API.G_RET_STS_SUCCESS;
9854: print_debuginfo(l_module_name, 'Returning success response ..');
9855:
9856: print_debuginfo(l_module_name, 'EXIT');
9857:

Line 9871: x_return_status := FND_API.G_RET_STS_ERROR;

9867: FND_MSG_PUB.add_exc_msg(G_PKG_NAME, l_module_name, null);
9868:
9869: ROLLBACK;
9870:
9871: x_return_status := FND_API.G_RET_STS_ERROR;
9872:
9873: print_debuginfo(l_module_name, 'EXIT');
9874:
9875: END lock_pmt_entity;

Line 9990: x_return_status := FND_API.G_RET_STS_SUCCESS;

9986: * with a concurrent request id.
9987: */
9988: COMMIT;
9989:
9990: x_return_status := FND_API.G_RET_STS_SUCCESS;
9991: print_debuginfo(l_module_name, 'Returning success response ..');
9992:
9993: print_debuginfo(l_module_name, 'EXIT');
9994:

Line 10008: x_return_status := FND_API.G_RET_STS_ERROR;

10004: FND_MSG_PUB.add_exc_msg(G_PKG_NAME, l_module_name, null);
10005:
10006: ROLLBACK;
10007:
10008: x_return_status := FND_API.G_RET_STS_ERROR;
10009:
10010: print_debuginfo(l_module_name, 'EXIT');
10011:
10012: END unlock_pmt_entity;

Line 10066: x_return_status := FND_API.G_RET_STS_SUCCESS;

10062: null;
10063: end;
10064:
10065: if(l_count<>0) then
10066: x_return_status := FND_API.G_RET_STS_SUCCESS;
10067: return;
10068: end if;
10069:
10070: OPEN c_pay_function;

Line 10093: x_return_status := FND_API.G_RET_STS_SUCCESS;

10089: end if;
10090: end loop;
10091: close c_pay_function;
10092:
10093: x_return_status := FND_API.G_RET_STS_SUCCESS;
10094: return;
10095: EXCEPTION
10096:
10097: WHEN OTHERS THEN

Line 10107: x_return_status := FND_API.G_RET_STS_ERROR;

10103: /*
10104: * The error message would have already been set.
10105: * Just set the error status here.
10106: */
10107: x_return_status := FND_API.G_RET_STS_ERROR;
10108:
10109: print_debuginfo(l_module_name, 'EXIT');
10110:
10111: end populatePaymentFunctions;

Line 10158: x_return_status := FND_API.G_RET_STS_SUCCESS;

10154: populatePaymentFunctions(x_return_status, x_return_message);
10155: x_access_flag:='N';
10156:
10157: /* Initialize return status */
10158: x_return_status := FND_API.G_RET_STS_SUCCESS;
10159:
10160: select count(1)
10161: into l_function_count
10162: from iby_process_functions pfun

Line 10201: x_return_status := FND_API.G_RET_STS_ERROR;

10197:
10198: FND_MESSAGE.set_name('IBY', l_message_code);
10199: FND_MSG_PUB.add;
10200:
10201: x_return_status := FND_API.G_RET_STS_ERROR;
10202:
10203: FND_MSG_PUB.Count_And_Get(
10204: p_encoded => FND_API.G_FALSE,
10205: p_count => l_msg_count,

Line 10204: p_encoded => FND_API.G_FALSE,

10200:
10201: x_return_status := FND_API.G_RET_STS_ERROR;
10202:
10203: FND_MSG_PUB.Count_And_Get(
10204: p_encoded => FND_API.G_FALSE,
10205: p_count => l_msg_count,
10206: p_data => x_return_message
10207: );
10208:

Line 10226: x_return_status := FND_API.G_RET_STS_ERROR;

10222: /*
10223: * The error message would have already been set.
10224: * Just set the error status here.
10225: */
10226: x_return_status := FND_API.G_RET_STS_ERROR;
10227:
10228: print_debuginfo(l_module_name, 'EXIT');
10229: end checkUserAccess;
10230:

Line 10651: x_return_status := FND_API.G_RET_STS_ERROR;

10647:
10648: print_debuginfo(l_module_name, 'SQLCODE: ' || SQLCODE);
10649: print_debuginfo(l_module_name, 'SQLERRM: ' || SQLERRM);
10650:
10651: x_return_status := FND_API.G_RET_STS_ERROR;
10652:
10653: print_debuginfo(l_module_name, 'Returning error status: '
10654: || x_return_status
10655: );

Line 10987: x_return_status := FND_API.G_RET_STS_SUCCESS;

10983:
10984: BEGIN
10985: print_debuginfo(l_module_name, 'ENTER');
10986:
10987: x_return_status := FND_API.G_RET_STS_SUCCESS;
10988: FND_MSG_PUB.initialize;
10989:
10990: /* set the context for the request set IBY_SECURITY_MASKING_REQ_SET */
10991: l_success := fnd_submit.set_request_set('IBY', 'IBY_SECURITY_MASKING_REQ_SET');

Line 11030: x_return_status := FND_API.G_RET_STS_ERROR;

11026: raise submit_failed;
11027: end if;
11028: EXCEPTION
11029: WHEN submit_failed THEN
11030: x_return_status := FND_API.G_RET_STS_ERROR;
11031: print_debuginfo(l_module_name, 'Exception submit_failed - ' || l_phase);
11032: FND_MSG_PUB.add_exc_msg(G_PKG_NAME, l_module_name, null);
11033:
11034: WHEN others THEN

Line 11035: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;

11031: print_debuginfo(l_module_name, 'Exception submit_failed - ' || l_phase);
11032: FND_MSG_PUB.add_exc_msg(G_PKG_NAME, l_module_name, null);
11033:
11034: WHEN others THEN
11035: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
11036: print_debuginfo(l_module_name, 'Exception others.');
11037: print_debuginfo(l_module_name, 'SQL code: ' || SQLCODE);
11038: print_debuginfo(l_module_name, 'SQL err msg: '|| SQLERRM);
11039: FND_MSG_PUB.add_exc_msg(G_PKG_NAME, l_module_name, null);

Line 11082: x_return_status := FND_API.G_RET_STS_SUCCESS;

11078:
11079: BEGIN
11080: print_debuginfo(l_module_name, 'ENTER');
11081:
11082: x_return_status := FND_API.G_RET_STS_SUCCESS;
11083: FND_MSG_PUB.initialize;
11084:
11085: /* set the context for the request set IBY_SECURITY_DECRYPT_REQ_SET */
11086: l_success := fnd_submit.set_request_set('IBY', 'IBY_SECURITY_DECRYPT_REQ_SET');

Line 11149: x_return_status := FND_API.G_RET_STS_ERROR;

11145: raise submit_failed;
11146: end if;
11147: EXCEPTION
11148: WHEN submit_failed THEN
11149: x_return_status := FND_API.G_RET_STS_ERROR;
11150: print_debuginfo(l_module_name, 'Exception submit_failed - ' || l_phase);
11151: FND_MSG_PUB.add_exc_msg(G_PKG_NAME, l_module_name, null);
11152:
11153: WHEN others THEN

Line 11154: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;

11150: print_debuginfo(l_module_name, 'Exception submit_failed - ' || l_phase);
11151: FND_MSG_PUB.add_exc_msg(G_PKG_NAME, l_module_name, null);
11152:
11153: WHEN others THEN
11154: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
11155: print_debuginfo(l_module_name, 'Exception others.');
11156: print_debuginfo(l_module_name, 'SQL code: ' || SQLCODE);
11157: print_debuginfo(l_module_name, 'SQL err msg: '|| SQLERRM);
11158: FND_MSG_PUB.add_exc_msg(G_PKG_NAME, l_module_name, null);

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

11163: | NAME:
11164: | get_conc_request_status
11165: |
11166: | PURPOSE:
11167: | Get the concurrent request id status using the FND API.
11168: |
11169: | PARAMETERS:
11170: | IN x_request_id
11171: |

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

11193:
11194: BEGIN
11195: IF (x_request_id IS NOT NULL) THEN
11196: v_request_id := x_request_id;
11197: -- call FND API to get request status
11198: v_call_status := FND_CONCURRENT.get_request_status(
11199: v_request_id,
11200: null, null,
11201: v_req_phase_t, v_req_status_t,

Line 11507: x_return_status := FND_API.G_RET_STS_SUCCESS;

11503:
11504: populatePaymentFunctions(x_return_status, x_return_message);
11505:
11506: /* Initialize return status */
11507: x_return_status := FND_API.G_RET_STS_SUCCESS;
11508:
11509: select count(1)
11510: into l_doc_function_count
11511: FROM IBY_DOCS_PAYABLE_ALL docs

Line 11595: x_return_status := FND_API.G_RET_STS_ERROR;

11591: /*
11592: * The error message would have already been set.
11593: * Just set the error status here.
11594: */
11595: x_return_status := FND_API.G_RET_STS_ERROR;
11596:
11597: print_debuginfo(l_module_name, 'EXIT');
11598:
11599: