eTRM uses javascript that opens and focuses a separate window to display reports. Your browser does not appear to support javascript. This should not prevent you from using eTRM but it does mean the window focus feature will not work. Please check the contents of other windows on your desktop if you click on a link that does not appear to do anything.

APPS.ZX_API_PUB dependencies on FND_MSG_PUB

Line 9: G_MSG_UERROR CONSTANT NUMBER := FND_MSG_PUB.G_MSG_LVL_UNEXP_ERROR;

5: | Global Data Types |
6: * ======================================================================*/
7:
8: G_PKG_NAME CONSTANT VARCHAR2(30) := 'ZX_API_PUB';
9: G_MSG_UERROR CONSTANT NUMBER := FND_MSG_PUB.G_MSG_LVL_UNEXP_ERROR;
10: G_MSG_ERROR CONSTANT NUMBER := FND_MSG_PUB.G_MSG_LVL_ERROR;
11: G_MSG_SUCCESS CONSTANT NUMBER := FND_MSG_PUB.G_MSG_LVL_SUCCESS;
12: G_MSG_HIGH CONSTANT NUMBER := FND_MSG_PUB.G_MSG_LVL_DEBUG_HIGH;
13: G_MSG_MEDIUM CONSTANT NUMBER := FND_MSG_PUB.G_MSG_LVL_DEBUG_MEDIUM;

Line 10: G_MSG_ERROR CONSTANT NUMBER := FND_MSG_PUB.G_MSG_LVL_ERROR;

6: * ======================================================================*/
7:
8: G_PKG_NAME CONSTANT VARCHAR2(30) := 'ZX_API_PUB';
9: G_MSG_UERROR CONSTANT NUMBER := FND_MSG_PUB.G_MSG_LVL_UNEXP_ERROR;
10: G_MSG_ERROR CONSTANT NUMBER := FND_MSG_PUB.G_MSG_LVL_ERROR;
11: G_MSG_SUCCESS CONSTANT NUMBER := FND_MSG_PUB.G_MSG_LVL_SUCCESS;
12: G_MSG_HIGH CONSTANT NUMBER := FND_MSG_PUB.G_MSG_LVL_DEBUG_HIGH;
13: G_MSG_MEDIUM CONSTANT NUMBER := FND_MSG_PUB.G_MSG_LVL_DEBUG_MEDIUM;
14: G_MSG_LOW CONSTANT NUMBER := FND_MSG_PUB.G_MSG_LVL_DEBUG_LOW;

Line 11: G_MSG_SUCCESS CONSTANT NUMBER := FND_MSG_PUB.G_MSG_LVL_SUCCESS;

7:
8: G_PKG_NAME CONSTANT VARCHAR2(30) := 'ZX_API_PUB';
9: G_MSG_UERROR CONSTANT NUMBER := FND_MSG_PUB.G_MSG_LVL_UNEXP_ERROR;
10: G_MSG_ERROR CONSTANT NUMBER := FND_MSG_PUB.G_MSG_LVL_ERROR;
11: G_MSG_SUCCESS CONSTANT NUMBER := FND_MSG_PUB.G_MSG_LVL_SUCCESS;
12: G_MSG_HIGH CONSTANT NUMBER := FND_MSG_PUB.G_MSG_LVL_DEBUG_HIGH;
13: G_MSG_MEDIUM CONSTANT NUMBER := FND_MSG_PUB.G_MSG_LVL_DEBUG_MEDIUM;
14: G_MSG_LOW CONSTANT NUMBER := FND_MSG_PUB.G_MSG_LVL_DEBUG_LOW;
15: G_LINES_PER_FETCH CONSTANT NUMBER := 1000;

Line 12: G_MSG_HIGH CONSTANT NUMBER := FND_MSG_PUB.G_MSG_LVL_DEBUG_HIGH;

8: G_PKG_NAME CONSTANT VARCHAR2(30) := 'ZX_API_PUB';
9: G_MSG_UERROR CONSTANT NUMBER := FND_MSG_PUB.G_MSG_LVL_UNEXP_ERROR;
10: G_MSG_ERROR CONSTANT NUMBER := FND_MSG_PUB.G_MSG_LVL_ERROR;
11: G_MSG_SUCCESS CONSTANT NUMBER := FND_MSG_PUB.G_MSG_LVL_SUCCESS;
12: G_MSG_HIGH CONSTANT NUMBER := FND_MSG_PUB.G_MSG_LVL_DEBUG_HIGH;
13: G_MSG_MEDIUM CONSTANT NUMBER := FND_MSG_PUB.G_MSG_LVL_DEBUG_MEDIUM;
14: G_MSG_LOW CONSTANT NUMBER := FND_MSG_PUB.G_MSG_LVL_DEBUG_LOW;
15: G_LINES_PER_FETCH CONSTANT NUMBER := 1000;
16:

Line 13: G_MSG_MEDIUM CONSTANT NUMBER := FND_MSG_PUB.G_MSG_LVL_DEBUG_MEDIUM;

9: G_MSG_UERROR CONSTANT NUMBER := FND_MSG_PUB.G_MSG_LVL_UNEXP_ERROR;
10: G_MSG_ERROR CONSTANT NUMBER := FND_MSG_PUB.G_MSG_LVL_ERROR;
11: G_MSG_SUCCESS CONSTANT NUMBER := FND_MSG_PUB.G_MSG_LVL_SUCCESS;
12: G_MSG_HIGH CONSTANT NUMBER := FND_MSG_PUB.G_MSG_LVL_DEBUG_HIGH;
13: G_MSG_MEDIUM CONSTANT NUMBER := FND_MSG_PUB.G_MSG_LVL_DEBUG_MEDIUM;
14: G_MSG_LOW CONSTANT NUMBER := FND_MSG_PUB.G_MSG_LVL_DEBUG_LOW;
15: G_LINES_PER_FETCH CONSTANT NUMBER := 1000;
16:
17: G_CURRENT_RUNTIME_LEVEL CONSTANT NUMBER := FND_LOG.G_CURRENT_RUNTIME_LEVEL;

Line 14: G_MSG_LOW CONSTANT NUMBER := FND_MSG_PUB.G_MSG_LVL_DEBUG_LOW;

10: G_MSG_ERROR CONSTANT NUMBER := FND_MSG_PUB.G_MSG_LVL_ERROR;
11: G_MSG_SUCCESS CONSTANT NUMBER := FND_MSG_PUB.G_MSG_LVL_SUCCESS;
12: G_MSG_HIGH CONSTANT NUMBER := FND_MSG_PUB.G_MSG_LVL_DEBUG_HIGH;
13: G_MSG_MEDIUM CONSTANT NUMBER := FND_MSG_PUB.G_MSG_LVL_DEBUG_MEDIUM;
14: G_MSG_LOW CONSTANT NUMBER := FND_MSG_PUB.G_MSG_LVL_DEBUG_LOW;
15: G_LINES_PER_FETCH CONSTANT NUMBER := 1000;
16:
17: G_CURRENT_RUNTIME_LEVEL CONSTANT NUMBER := FND_LOG.G_CURRENT_RUNTIME_LEVEL;
18: G_LEVEL_UNEXPECTED CONSTANT NUMBER := FND_LOG.LEVEL_UNEXPECTED;

Line 844: FND_MSG_PUB.initialize;

840: l_init_msg_list := p_init_msg_list;
841: END IF;
842:
843: IF FND_API.to_Boolean(l_init_msg_list) THEN
844: FND_MSG_PUB.initialize;
845: END IF;
846:
847:
848: /*-----------------------------------------+

Line 1210: FND_MSG_PUB.Add;

1206: END IF;
1207:
1208: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
1209: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
1210: FND_MSG_PUB.Add;
1211:
1212: IF c_HEADERS%ISOPEN THEN
1213: close c_HEADERS;
1214: END IF;

Line 1271: FND_MSG_PUB.Add;

1267: END IF;
1268:
1269: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
1270: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
1271: FND_MSG_PUB.Add;
1272:
1273: IF c_HEADERS%ISOPEN THEN
1274: close c_HEADERS;
1275: END IF;

Line 1359: FND_MSG_PUB.add;

1355: IF common_header_info%ISOPEN THEN CLOSE common_header_info; END IF;
1356: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
1357: DUMP_MSG;
1358: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
1359: FND_MSG_PUB.add;
1360: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
1361: p_count => x_msg_count,
1362: p_data => x_msg_data
1363: );

Line 1360: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

1356: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
1357: DUMP_MSG;
1358: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
1359: FND_MSG_PUB.add;
1360: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
1361: p_count => x_msg_count,
1362: p_data => x_msg_data
1363: );
1364: IF ( G_LEVEL_ERROR >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 1375: FND_MSG_PUB.add;

1371: IF common_header_info%ISOPEN THEN CLOSE common_header_info; END IF;
1372: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
1373: DUMP_MSG;
1374: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
1375: FND_MSG_PUB.add;
1376: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
1377: p_count => x_msg_count,
1378: p_data => x_msg_data
1379: );

Line 1376: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

1372: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
1373: DUMP_MSG;
1374: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
1375: FND_MSG_PUB.add;
1376: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
1377: p_count => x_msg_count,
1378: p_data => x_msg_data
1379: );
1380: IF ( G_LEVEL_UNEXPECTED >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 1451: FND_MSG_PUB.initialize;

1447: l_init_msg_list := p_init_msg_list;
1448: END IF;
1449:
1450: IF FND_API.to_Boolean(l_init_msg_list) THEN
1451: FND_MSG_PUB.initialize;
1452: END IF;
1453:
1454: /*-----------------------------------------+
1455: | Initialize return status to SUCCESS |

Line 2068: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

2064: WHEN FND_API.G_EXC_ERROR THEN
2065: ROLLBACK TO Calculate_tax_PVT;
2066: x_return_status := FND_API.G_RET_STS_ERROR ;
2067: /*---------------------------------------------------------+
2068: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
2069: | in the message stack. If there is only one message in |
2070: | the stack it retrieves this message |
2071: +---------------------------------------------------------*/
2072: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 2072: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

2068: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
2069: | in the message stack. If there is only one message in |
2070: | the stack it retrieves this message |
2071: +---------------------------------------------------------*/
2072: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
2073: p_count => x_msg_count,
2074: p_data => x_msg_data
2075: );
2076:

Line 2085: FND_MSG_PUB.Add;

2081: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
2082: ROLLBACK TO Calculate_tax_PVT;
2083: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
2084: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
2085: FND_MSG_PUB.Add;
2086: /*---------------------------------------------------------+
2087: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
2088: | in the message stack. If there is only one message in |
2089: | the stack it retrieves this message |

Line 2087: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

2083: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
2084: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
2085: FND_MSG_PUB.Add;
2086: /*---------------------------------------------------------+
2087: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
2088: | in the message stack. If there is only one message in |
2089: | the stack it retrieves this message |
2090: +---------------------------------------------------------*/
2091: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 2091: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

2087: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
2088: | in the message stack. If there is only one message in |
2089: | the stack it retrieves this message |
2090: +---------------------------------------------------------*/
2091: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
2092: p_count => x_msg_count,
2093: p_data => x_msg_data
2094: );
2095: IF ( G_LEVEL_ERROR >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 2103: FND_MSG_PUB.Add;

2099: WHEN OTHERS THEN
2100: ROLLBACK TO Calculate_tax_PVT;
2101: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
2102: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
2103: FND_MSG_PUB.Add;
2104: /*---------------------------------------------------------+
2105: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
2106: | in the message stack. If there is only one message in |
2107: | the stack it retrieves this message |

Line 2105: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

2101: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
2102: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
2103: FND_MSG_PUB.Add;
2104: /*---------------------------------------------------------+
2105: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
2106: | in the message stack. If there is only one message in |
2107: | the stack it retrieves this message |
2108: +---------------------------------------------------------*/
2109: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 2109: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

2105: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
2106: | in the message stack. If there is only one message in |
2107: | the stack it retrieves this message |
2108: +---------------------------------------------------------*/
2109: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
2110: p_count => x_msg_count,
2111: p_data => x_msg_data
2112: );
2113:

Line 2207: FND_MSG_PUB.initialize;

2203: l_init_msg_list := p_init_msg_list;
2204: END IF;
2205:
2206: IF FND_API.to_Boolean(l_init_msg_list) THEN
2207: FND_MSG_PUB.initialize;
2208: END IF;
2209:
2210:
2211: /*-----------------------------------------+

Line 2469: FND_MSG_PUB.Add;

2465: ROLLBACK TO Import_Document_PVT;
2466: --Close all open cursors
2467: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
2468: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
2469: FND_MSG_PUB.Add;
2470: /*---------------------------------------------------------+
2471: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
2472: | in the message stack. If there is only one message in |
2473: | the stack it retrieves this message |

Line 2471: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

2467: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
2468: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
2469: FND_MSG_PUB.Add;
2470: /*---------------------------------------------------------+
2471: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
2472: | in the message stack. If there is only one message in |
2473: | the stack it retrieves this message |
2474: +---------------------------------------------------------*/
2475: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 2475: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

2471: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
2472: | in the message stack. If there is only one message in |
2473: | the stack it retrieves this message |
2474: +---------------------------------------------------------*/
2475: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
2476: p_count => x_msg_count,
2477: p_data => x_msg_data
2478: );
2479: IF ( G_LEVEL_ERROR >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 2488: FND_MSG_PUB.Add;

2484: ROLLBACK TO Import_Document_PVT;
2485: --Close all open cursors
2486: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
2487: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
2488: FND_MSG_PUB.Add;
2489: /*---------------------------------------------------------+
2490: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
2491: | in the message stack. If there is only one message in |
2492: | the stack it retrieves this message |

Line 2490: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

2486: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
2487: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
2488: FND_MSG_PUB.Add;
2489: /*---------------------------------------------------------+
2490: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
2491: | in the message stack. If there is only one message in |
2492: | the stack it retrieves this message |
2493: +---------------------------------------------------------*/
2494: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 2494: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

2490: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
2491: | in the message stack. If there is only one message in |
2492: | the stack it retrieves this message |
2493: +---------------------------------------------------------*/
2494: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
2495: p_count => x_msg_count,
2496: p_data => x_msg_data
2497: );
2498:

Line 2561: FND_MSG_PUB.initialize;

2557: l_init_msg_list := p_init_msg_list;
2558: END IF;
2559:
2560: IF FND_API.to_Boolean(l_init_msg_list) THEN
2561: FND_MSG_PUB.initialize;
2562: END IF;
2563:
2564: /*-----------------------------------------+
2565: | Initialize return status to SUCCESS |

Line 2837: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

2833: WHEN FND_API.G_EXC_ERROR THEN
2834: ROLLBACK TO Synchronize_tax_PVT;
2835: x_return_status := FND_API.G_RET_STS_ERROR ;
2836: /*---------------------------------------------------------+
2837: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
2838: | in the message stack. If there is only one message in |
2839: | the stack it retrieves this message |
2840: +---------------------------------------------------------*/
2841: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 2841: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

2837: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
2838: | in the message stack. If there is only one message in |
2839: | the stack it retrieves this message |
2840: +---------------------------------------------------------*/
2841: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
2842: p_count => x_msg_count,
2843: p_data => x_msg_data
2844: );
2845: IF ( G_LEVEL_ERROR >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 2853: FND_MSG_PUB.Add;

2849: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
2850: ROLLBACK TO Synchronize_tax_PVT;
2851: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
2852: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
2853: FND_MSG_PUB.Add;
2854: /*---------------------------------------------------------+
2855: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
2856: | in the message stack. If there is only one message in |
2857: | the stack it retrieves this message |

Line 2855: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

2851: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
2852: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
2853: FND_MSG_PUB.Add;
2854: /*---------------------------------------------------------+
2855: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
2856: | in the message stack. If there is only one message in |
2857: | the stack it retrieves this message |
2858: +---------------------------------------------------------*/
2859: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 2859: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

2855: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
2856: | in the message stack. If there is only one message in |
2857: | the stack it retrieves this message |
2858: +---------------------------------------------------------*/
2859: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
2860: p_count => x_msg_count,
2861: p_data => x_msg_data
2862: );
2863: IF ( G_LEVEL_ERROR >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 2871: FND_MSG_PUB.Add;

2867: WHEN OTHERS THEN
2868: ROLLBACK TO Synchronize_tax_PVT;
2869: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
2870: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
2871: FND_MSG_PUB.Add;
2872: /*---------------------------------------------------------+
2873: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
2874: | in the message stack. If there is only one message in |
2875: | the stack it retrieves this message |

Line 2873: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

2869: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
2870: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
2871: FND_MSG_PUB.Add;
2872: /*---------------------------------------------------------+
2873: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
2874: | in the message stack. If there is only one message in |
2875: | the stack it retrieves this message |
2876: +---------------------------------------------------------*/
2877: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 2877: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

2873: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
2874: | in the message stack. If there is only one message in |
2875: | the stack it retrieves this message |
2876: +---------------------------------------------------------*/
2877: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
2878: p_count => x_msg_count,
2879: p_data => x_msg_data
2880: );
2881: IF ( G_LEVEL_UNEXPECTED >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 2965: FND_MSG_PUB.initialize;

2961: l_init_msg_list := p_init_msg_list;
2962: END IF;
2963:
2964: IF FND_API.to_Boolean(l_init_msg_list) THEN
2965: FND_MSG_PUB.initialize;
2966: END IF;
2967:
2968: /*-----------------------------------------+
2969: | Initialize return status to SUCCESS |

Line 3169: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

3165: WHEN FND_API.G_EXC_ERROR THEN
3166: ROLLBACK TO Override_Tax_PVT;
3167: x_return_status := FND_API.G_RET_STS_ERROR ;
3168: /*---------------------------------------------------------+
3169: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
3170: | in the message stack. If there is only one message in |
3171: | the stack it retrieves this message |
3172: +---------------------------------------------------------*/
3173: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 3173: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

3169: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
3170: | in the message stack. If there is only one message in |
3171: | the stack it retrieves this message |
3172: +---------------------------------------------------------*/
3173: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
3174: p_count => x_msg_count,
3175: p_data => x_msg_data
3176: );
3177: IF ( G_LEVEL_ERROR >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 3185: FND_MSG_PUB.Add;

3181: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
3182: ROLLBACK TO Override_Tax_PVT;
3183: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
3184: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
3185: FND_MSG_PUB.Add;
3186: /*---------------------------------------------------------+
3187: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
3188: | in the message stack. If there is only one message in |
3189: | the stack it retrieves this message |

Line 3187: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

3183: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
3184: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
3185: FND_MSG_PUB.Add;
3186: /*---------------------------------------------------------+
3187: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
3188: | in the message stack. If there is only one message in |
3189: | the stack it retrieves this message |
3190: +---------------------------------------------------------*/
3191: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 3191: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

3187: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
3188: | in the message stack. If there is only one message in |
3189: | the stack it retrieves this message |
3190: +---------------------------------------------------------*/
3191: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
3192: p_count => x_msg_count,
3193: p_data => x_msg_data
3194: );
3195: IF ( G_LEVEL_ERROR >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 3203: FND_MSG_PUB.Add;

3199: WHEN OTHERS THEN
3200: ROLLBACK TO Override_Tax_PVT;
3201: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
3202: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
3203: FND_MSG_PUB.Add;
3204: /*---------------------------------------------------------+
3205: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
3206: | in the message stack. If there is only one message in |
3207: | the stack it retrieves this message |

Line 3205: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

3201: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
3202: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
3203: FND_MSG_PUB.Add;
3204: /*---------------------------------------------------------+
3205: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
3206: | in the message stack. If there is only one message in |
3207: | the stack it retrieves this message |
3208: +---------------------------------------------------------*/
3209: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 3209: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

3205: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
3206: | in the message stack. If there is only one message in |
3207: | the stack it retrieves this message |
3208: +---------------------------------------------------------*/
3209: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
3210: p_count => x_msg_count,
3211: p_data => x_msg_data
3212: );
3213: IF ( G_LEVEL_UNEXPECTED >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 3271: FND_MSG_PUB.initialize;

3267: l_init_msg_list := p_init_msg_list;
3268: END IF;
3269:
3270: IF FND_API.to_Boolean(l_init_msg_list) THEN
3271: FND_MSG_PUB.initialize;
3272: END IF;
3273:
3274: /*-----------------------------------------+
3275: | Initialize return status to SUCCESS |

Line 3323: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

3319: WHEN FND_API.G_EXC_ERROR THEN
3320: ROLLBACK TO global_document_update_PVT;
3321: x_return_status := FND_API.G_RET_STS_ERROR ;
3322: /*---------------------------------------------------------+
3323: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
3324: | in the message stack. If there is only one message in |
3325: | the stack it retrieves this message |
3326: +---------------------------------------------------------*/
3327: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 3327: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

3323: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
3324: | in the message stack. If there is only one message in |
3325: | the stack it retrieves this message |
3326: +---------------------------------------------------------*/
3327: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
3328: p_count => x_msg_count,
3329: p_data => x_msg_data
3330: );
3331: IF ( G_LEVEL_ERROR >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 3339: FND_MSG_PUB.Add;

3335: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
3336: ROLLBACK TO global_document_update_PVT;
3337: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
3338: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
3339: FND_MSG_PUB.Add;
3340: /*---------------------------------------------------------+
3341: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
3342: | in the message stack. If there is only one message in |
3343: | the stack it retrieves this message |

Line 3341: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

3337: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
3338: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
3339: FND_MSG_PUB.Add;
3340: /*---------------------------------------------------------+
3341: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
3342: | in the message stack. If there is only one message in |
3343: | the stack it retrieves this message |
3344: +---------------------------------------------------------*/
3345: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 3345: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

3341: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
3342: | in the message stack. If there is only one message in |
3343: | the stack it retrieves this message |
3344: +---------------------------------------------------------*/
3345: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
3346: p_count => x_msg_count,
3347: p_data => x_msg_data
3348: );
3349: IF ( G_LEVEL_ERROR >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 3357: FND_MSG_PUB.Add;

3353: WHEN OTHERS THEN
3354: ROLLBACK TO global_document_update_PVT;
3355: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
3356: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
3357: FND_MSG_PUB.Add;
3358: /*---------------------------------------------------------+
3359: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
3360: | in the message stack. If there is only one message in |
3361: | the stack it retrieves this message |

Line 3359: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

3355: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
3356: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
3357: FND_MSG_PUB.Add;
3358: /*---------------------------------------------------------+
3359: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
3360: | in the message stack. If there is only one message in |
3361: | the stack it retrieves this message |
3362: +---------------------------------------------------------*/
3363: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 3363: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

3359: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
3360: | in the message stack. If there is only one message in |
3361: | the stack it retrieves this message |
3362: +---------------------------------------------------------*/
3363: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
3364: p_count => x_msg_count,
3365: p_data => x_msg_data
3366: );
3367:

Line 3427: FND_MSG_PUB.initialize;

3423: l_init_msg_list := p_init_msg_list;
3424: END IF;
3425:
3426: IF FND_API.to_Boolean(l_init_msg_list) THEN
3427: FND_MSG_PUB.initialize;
3428: END IF;
3429:
3430: /*-----------------------------------------+
3431: | Initialize return status to SUCCESS |

Line 3607: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

3603: WHEN FND_API.G_EXC_ERROR THEN
3604: ROLLBACK TO global_document_update_PVT;
3605: x_return_status := FND_API.G_RET_STS_ERROR ;
3606: /*---------------------------------------------------------+
3607: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
3608: | in the message stack. If there is only one message in |
3609: | the stack it retrieves this message |
3610: +---------------------------------------------------------*/
3611: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 3611: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

3607: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
3608: | in the message stack. If there is only one message in |
3609: | the stack it retrieves this message |
3610: +---------------------------------------------------------*/
3611: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
3612: p_count => x_msg_count,
3613: p_data => x_msg_data
3614: );
3615: IF ( G_LEVEL_ERROR >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 3623: FND_MSG_PUB.Add;

3619: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
3620: ROLLBACK TO global_document_update_PVT;
3621: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
3622: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
3623: FND_MSG_PUB.Add;
3624: /*---------------------------------------------------------+
3625: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
3626: | in the message stack. If there is only one message in |
3627: | the stack it retrieves this message |

Line 3625: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

3621: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
3622: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
3623: FND_MSG_PUB.Add;
3624: /*---------------------------------------------------------+
3625: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
3626: | in the message stack. If there is only one message in |
3627: | the stack it retrieves this message |
3628: +---------------------------------------------------------*/
3629: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 3629: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

3625: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
3626: | in the message stack. If there is only one message in |
3627: | the stack it retrieves this message |
3628: +---------------------------------------------------------*/
3629: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
3630: p_count => x_msg_count,
3631: p_data => x_msg_data
3632: );
3633:

Line 3642: FND_MSG_PUB.Add;

3638: WHEN OTHERS THEN
3639: ROLLBACK TO global_document_update_PVT;
3640: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
3641: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
3642: FND_MSG_PUB.Add;
3643: /*---------------------------------------------------------+
3644: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
3645: | in the message stack. If there is only one message in |
3646: | the stack it retrieves this message |

Line 3644: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

3640: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
3641: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
3642: FND_MSG_PUB.Add;
3643: /*---------------------------------------------------------+
3644: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
3645: | in the message stack. If there is only one message in |
3646: | the stack it retrieves this message |
3647: +---------------------------------------------------------*/
3648: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 3648: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

3644: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
3645: | in the message stack. If there is only one message in |
3646: | the stack it retrieves this message |
3647: +---------------------------------------------------------*/
3648: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
3649: p_count => x_msg_count,
3650: p_data => x_msg_data
3651: );
3652: IF ( G_LEVEL_UNEXPECTED >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 3708: FND_MSG_PUB.initialize;

3704: l_init_msg_list := p_init_msg_list;
3705: END IF;
3706:
3707: IF FND_API.to_Boolean(l_init_msg_list) THEN
3708: FND_MSG_PUB.initialize;
3709: END IF;
3710:
3711: /*-----------------------------------------+
3712: | Initialize return status to SUCCESS |

Line 3809: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

3805: WHEN FND_API.G_EXC_ERROR THEN
3806: ROLLBACK TO mark_tax_lines_del_PVT;
3807: x_return_status := FND_API.G_RET_STS_ERROR ;
3808: /*---------------------------------------------------------+
3809: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
3810: | in the message stack. If there is only one message in |
3811: | the stack it retrieves this message |
3812: +---------------------------------------------------------*/
3813: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 3813: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

3809: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
3810: | in the message stack. If there is only one message in |
3811: | the stack it retrieves this message |
3812: +---------------------------------------------------------*/
3813: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
3814: p_count => x_msg_count,
3815: p_data => x_msg_data
3816: );
3817: IF ( G_LEVEL_ERROR >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 3825: FND_MSG_PUB.Add;

3821: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
3822: ROLLBACK TO mark_tax_lines_del_PVT;
3823: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
3824: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
3825: FND_MSG_PUB.Add;
3826: /*---------------------------------------------------------+
3827: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
3828: | in the message stack. If there is only one message in |
3829: | the stack it retrieves this message |

Line 3827: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

3823: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
3824: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
3825: FND_MSG_PUB.Add;
3826: /*---------------------------------------------------------+
3827: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
3828: | in the message stack. If there is only one message in |
3829: | the stack it retrieves this message |
3830: +---------------------------------------------------------*/
3831: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 3831: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

3827: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
3828: | in the message stack. If there is only one message in |
3829: | the stack it retrieves this message |
3830: +---------------------------------------------------------*/
3831: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
3832: p_count => x_msg_count,
3833: p_data => x_msg_data
3834: );
3835:

Line 3844: FND_MSG_PUB.Add;

3840: WHEN OTHERS THEN
3841: ROLLBACK TO mark_tax_lines_del_PVT;
3842: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
3843: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
3844: FND_MSG_PUB.Add;
3845: /*---------------------------------------------------------+
3846: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
3847: | in the message stack. If there is only one message in |
3848: | the stack it retrieves this message |

Line 3846: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

3842: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
3843: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
3844: FND_MSG_PUB.Add;
3845: /*---------------------------------------------------------+
3846: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
3847: | in the message stack. If there is only one message in |
3848: | the stack it retrieves this message |
3849: +---------------------------------------------------------*/
3850: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 3850: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

3846: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
3847: | in the message stack. If there is only one message in |
3848: | the stack it retrieves this message |
3849: +---------------------------------------------------------*/
3850: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
3851: p_count => x_msg_count,
3852: p_data => x_msg_data
3853: );
3854: IF ( G_LEVEL_UNEXPECTED >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 3915: FND_MSG_PUB.initialize;

3911: l_init_msg_list := p_init_msg_list;
3912: END IF;
3913:
3914: IF FND_API.to_Boolean(l_init_msg_list) THEN
3915: FND_MSG_PUB.initialize;
3916: END IF;
3917:
3918: /*-----------------------------------------+
3919: | Initialize return status to SUCCESS |

Line 4002: FND_MSG_PUB.Add;

3998: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
3999: ROLLBACK TO reverse_document_PVT;
4000: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
4001: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
4002: FND_MSG_PUB.Add;
4003: /*---------------------------------------------------------+
4004: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
4005: | in the message stack. If there is only one message in |
4006: | the stack it retrieves this message |

Line 4004: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

4000: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
4001: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
4002: FND_MSG_PUB.Add;
4003: /*---------------------------------------------------------+
4004: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
4005: | in the message stack. If there is only one message in |
4006: | the stack it retrieves this message |
4007: +---------------------------------------------------------*/
4008: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 4008: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

4004: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
4005: | in the message stack. If there is only one message in |
4006: | the stack it retrieves this message |
4007: +---------------------------------------------------------*/
4008: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
4009: p_count => x_msg_count,
4010: p_data => x_msg_data
4011: );
4012:

Line 4021: FND_MSG_PUB.Add;

4017: WHEN OTHERS THEN
4018: ROLLBACK TO reverse_document_PVT;
4019: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
4020: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
4021: FND_MSG_PUB.Add;
4022: /*---------------------------------------------------------+
4023: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
4024: | in the message stack. If there is only one message in |
4025: | the stack it retrieves this message |

Line 4023: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

4019: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
4020: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
4021: FND_MSG_PUB.Add;
4022: /*---------------------------------------------------------+
4023: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
4024: | in the message stack. If there is only one message in |
4025: | the stack it retrieves this message |
4026: +---------------------------------------------------------*/
4027: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 4027: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

4023: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
4024: | in the message stack. If there is only one message in |
4025: | the stack it retrieves this message |
4026: +---------------------------------------------------------*/
4027: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
4028: p_count => x_msg_count,
4029: p_data => x_msg_data
4030: );
4031:

Line 4088: FND_MSG_PUB.initialize;

4084: l_init_msg_list := p_init_msg_list;
4085: END IF;
4086:
4087: IF FND_API.to_Boolean(l_init_msg_list) THEN
4088: FND_MSG_PUB.initialize;
4089: END IF;
4090:
4091: /*-----------------------------------------+
4092: | Initialize return status to SUCCESS |

Line 4160: FND_MSG_PUB.ADD;

4156: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
4157: ROLLBACK TO reverse_distributions_PVT;
4158: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
4159: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
4160: FND_MSG_PUB.ADD;
4161: /*---------------------------------------------------------+
4162: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
4163: | in the message stack. If there is only one message in |
4164: | the stack it retrieves this message |

Line 4162: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

4158: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
4159: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
4160: FND_MSG_PUB.ADD;
4161: /*---------------------------------------------------------+
4162: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
4163: | in the message stack. If there is only one message in |
4164: | the stack it retrieves this message |
4165: +---------------------------------------------------------*/
4166: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 4166: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

4162: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
4163: | in the message stack. If there is only one message in |
4164: | the stack it retrieves this message |
4165: +---------------------------------------------------------*/
4166: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
4167: p_count => x_msg_count,
4168: p_data => x_msg_data
4169: );
4170: IF ( G_LEVEL_ERROR >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 4178: FND_MSG_PUB.ADD;

4174: WHEN OTHERS THEN
4175: ROLLBACK TO reverse_distributions_PVT;
4176: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
4177: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
4178: FND_MSG_PUB.ADD;
4179: /*---------------------------------------------------------+
4180: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
4181: | in the message stack. If there is only one message in |
4182: | the stack it retrieves this message |

Line 4180: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

4176: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
4177: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
4178: FND_MSG_PUB.ADD;
4179: /*---------------------------------------------------------+
4180: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
4181: | in the message stack. If there is only one message in |
4182: | the stack it retrieves this message |
4183: +---------------------------------------------------------*/
4184: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 4184: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

4180: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
4181: | in the message stack. If there is only one message in |
4182: | the stack it retrieves this message |
4183: +---------------------------------------------------------*/
4184: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
4185: p_count => x_msg_count,
4186: p_data => x_msg_data
4187: );
4188: IF ( G_LEVEL_UNEXPECTED >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 4244: FND_MSG_PUB.initialize;

4240: l_init_msg_list := p_init_msg_list;
4241: END IF;
4242:
4243: IF FND_API.to_Boolean(l_init_msg_list) THEN
4244: FND_MSG_PUB.initialize;
4245: END IF;
4246:
4247: /*-----------------------------------------+
4248: | Initialize return status to SUCCESS |

Line 4358: FND_MSG_PUB.ADD;

4354: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
4355: ROLLBACK TO reverse_doc_distribution_PVT;
4356: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
4357: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
4358: FND_MSG_PUB.ADD;
4359: /*---------------------------------------------------------+
4360: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
4361: | in the message stack. If there is only one message in |
4362: | the stack it retrieves this message |

Line 4360: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

4356: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
4357: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
4358: FND_MSG_PUB.ADD;
4359: /*---------------------------------------------------------+
4360: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
4361: | in the message stack. If there is only one message in |
4362: | the stack it retrieves this message |
4363: +---------------------------------------------------------*/
4364: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 4364: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

4360: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
4361: | in the message stack. If there is only one message in |
4362: | the stack it retrieves this message |
4363: +---------------------------------------------------------*/
4364: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
4365: p_count => x_msg_count,
4366: p_data => x_msg_data
4367: );
4368: IF ( G_LEVEL_ERROR >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 4376: FND_MSG_PUB.ADD;

4372: WHEN OTHERS THEN
4373: ROLLBACK TO reverse_doc_distribution_PVT;
4374: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
4375: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
4376: FND_MSG_PUB.ADD;
4377: /*---------------------------------------------------------+
4378: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
4379: | in the message stack. If there is only one message in |
4380: | the stack it retrieves this message |

Line 4378: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

4374: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
4375: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
4376: FND_MSG_PUB.ADD;
4377: /*---------------------------------------------------------+
4378: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
4379: | in the message stack. If there is only one message in |
4380: | the stack it retrieves this message |
4381: +---------------------------------------------------------*/
4382: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 4382: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

4378: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
4379: | in the message stack. If there is only one message in |
4380: | the stack it retrieves this message |
4381: +---------------------------------------------------------*/
4382: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
4383: p_count => x_msg_count,
4384: p_data => x_msg_data
4385: );
4386: IF ( G_LEVEL_UNEXPECTED >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 4569: FND_MSG_PUB.initialize;

4565: l_init_msg_list := p_init_msg_list;
4566: END IF;
4567:
4568: IF FND_API.to_Boolean(l_init_msg_list) THEN
4569: FND_MSG_PUB.initialize;
4570: END IF;
4571:
4572: /*-----------------------------------------+
4573: | Initialize return status to SUCCESS |

Line 5045: FND_MSG_PUB.Add;

5041: END IF;
5042:
5043: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
5044: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
5045: FND_MSG_PUB.Add;
5046:
5047: IF c_HEADERS%ISOPEN THEN
5048: close c_HEADERS;
5049: END IF;

Line 5075: FND_MSG_PUB.Add;

5071: --Close all open cursors
5072: IF headers%ISOPEN THEN CLOSE headers; END IF;
5073: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
5074: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
5075: FND_MSG_PUB.Add;
5076: /*---------------------------------------------------------+
5077: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
5078: | in the message stack. If there is only one message in |
5079: | the stack it retrieves this message |

Line 5077: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

5073: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
5074: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
5075: FND_MSG_PUB.Add;
5076: /*---------------------------------------------------------+
5077: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
5078: | in the message stack. If there is only one message in |
5079: | the stack it retrieves this message |
5080: +---------------------------------------------------------*/
5081: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 5081: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

5077: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
5078: | in the message stack. If there is only one message in |
5079: | the stack it retrieves this message |
5080: +---------------------------------------------------------*/
5081: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
5082: p_count => x_msg_count,
5083: p_data => x_msg_data
5084: );
5085: IF ( G_LEVEL_ERROR >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 5095: FND_MSG_PUB.Add;

5091: --Close all open cursors
5092: IF headers%ISOPEN THEN CLOSE headers; END IF;
5093: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
5094: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
5095: FND_MSG_PUB.Add;
5096: /*---------------------------------------------------------+
5097: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
5098: | in the message stack. If there is only one message in |
5099: | the stack it retrieves this message |

Line 5097: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

5093: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
5094: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
5095: FND_MSG_PUB.Add;
5096: /*---------------------------------------------------------+
5097: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
5098: | in the message stack. If there is only one message in |
5099: | the stack it retrieves this message |
5100: +---------------------------------------------------------*/
5101: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 5101: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

5097: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
5098: | in the message stack. If there is only one message in |
5099: | the stack it retrieves this message |
5100: +---------------------------------------------------------*/
5101: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
5102: p_count => x_msg_count,
5103: p_data => x_msg_data
5104: );
5105: IF ( G_LEVEL_UNEXPECTED >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 5164: FND_MSG_PUB.initialize;

5160: l_init_msg_list := p_init_msg_list;
5161: END IF;
5162:
5163: IF FND_API.to_Boolean(l_init_msg_list) THEN
5164: FND_MSG_PUB.initialize;
5165: END IF;
5166:
5167: /*-----------------------------------------+
5168: | Initialize return status to SUCCESS |

Line 5260: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

5256: WHEN FND_API.G_EXC_ERROR THEN
5257: ROLLBACK TO override_recovery_PVT;
5258: x_return_status := FND_API.G_RET_STS_ERROR ;
5259: /*---------------------------------------------------------+
5260: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
5261: | in the message stack. If there is only one message in |
5262: | the stack it retrieves this message |
5263: +---------------------------------------------------------*/
5264: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 5264: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

5260: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
5261: | in the message stack. If there is only one message in |
5262: | the stack it retrieves this message |
5263: +---------------------------------------------------------*/
5264: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
5265: p_count => x_msg_count,
5266: p_data => x_msg_data
5267: );
5268: IF ( G_LEVEL_ERROR >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 5276: FND_MSG_PUB.Add;

5272: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
5273: ROLLBACK TO override_recovery_PVT;
5274: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
5275: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
5276: FND_MSG_PUB.Add;
5277: /*---------------------------------------------------------+
5278: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
5279: | in the message stack. If there is only one message in |
5280: | the stack it retrieves this message |

Line 5278: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

5274: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
5275: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
5276: FND_MSG_PUB.Add;
5277: /*---------------------------------------------------------+
5278: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
5279: | in the message stack. If there is only one message in |
5280: | the stack it retrieves this message |
5281: +---------------------------------------------------------*/
5282: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 5282: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

5278: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
5279: | in the message stack. If there is only one message in |
5280: | the stack it retrieves this message |
5281: +---------------------------------------------------------*/
5282: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
5283: p_count => x_msg_count,
5284: p_data => x_msg_data
5285: );
5286: IF ( G_LEVEL_ERROR >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 5299: FND_MSG_PUB.Add;

5295: +-------------------------------------------------------*/
5296: ROLLBACK TO override_recovery_PVT;
5297: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
5298: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
5299: FND_MSG_PUB.Add;
5300: /*---------------------------------------------------------+
5301: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
5302: | in the message stack. If there is only one message in |
5303: | the stack it retrieves this message |

Line 5301: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

5297: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
5298: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
5299: FND_MSG_PUB.Add;
5300: /*---------------------------------------------------------+
5301: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
5302: | in the message stack. If there is only one message in |
5303: | the stack it retrieves this message |
5304: +---------------------------------------------------------*/
5305: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 5305: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

5301: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
5302: | in the message stack. If there is only one message in |
5303: | the stack it retrieves this message |
5304: +---------------------------------------------------------*/
5305: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
5306: p_count => x_msg_count,
5307: p_data => x_msg_data
5308: );
5309: IF ( G_LEVEL_UNEXPECTED >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 5392: FND_MSG_PUB.initialize;

5388: l_init_msg_list := p_init_msg_list;
5389: END IF;
5390:
5391: IF FND_API.to_Boolean(l_init_msg_list) THEN
5392: FND_MSG_PUB.initialize;
5393: END IF;
5394:
5395: /*-----------------------------------------+
5396: | Initialize return status to SUCCESS |

Line 5515: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

5511: WHEN FND_API.G_EXC_ERROR THEN
5512: ROLLBACK TO FREEZE_TAX_DISTRIBUTIONS_PVT;
5513: x_return_status := FND_API.G_RET_STS_ERROR ;
5514: /*---------------------------------------------------------+
5515: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
5516: | in the message stack. If there is only one message in |
5517: | the stack it retrieves this message |
5518: +---------------------------------------------------------*/
5519: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 5519: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

5515: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
5516: | in the message stack. If there is only one message in |
5517: | the stack it retrieves this message |
5518: +---------------------------------------------------------*/
5519: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
5520: p_count => x_msg_count,
5521: p_data => x_msg_data
5522: );
5523:

Line 5532: FND_MSG_PUB.Add;

5528: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
5529: ROLLBACK TO FREEZE_TAX_DISTRIBUTIONS_PVT;
5530: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
5531: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
5532: FND_MSG_PUB.Add;
5533: /*---------------------------------------------------------+
5534: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
5535: | in the message stack. If there is only one message in |
5536: | the stack it retrieves this message |

Line 5534: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

5530: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
5531: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
5532: FND_MSG_PUB.Add;
5533: /*---------------------------------------------------------+
5534: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
5535: | in the message stack. If there is only one message in |
5536: | the stack it retrieves this message |
5537: +---------------------------------------------------------*/
5538: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 5538: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

5534: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
5535: | in the message stack. If there is only one message in |
5536: | the stack it retrieves this message |
5537: +---------------------------------------------------------*/
5538: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
5539: p_count => x_msg_count,
5540: p_data => x_msg_data
5541: );
5542: IF ( G_LEVEL_ERROR >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 5550: FND_MSG_PUB.Add;

5546: WHEN OTHERS THEN
5547: ROLLBACK TO FREEZE_TAX_DISTRIBUTIONS_PVT;
5548: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
5549: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
5550: FND_MSG_PUB.Add;
5551: /*---------------------------------------------------------+
5552: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
5553: | in the message stack. If there is only one message in |
5554: | the stack it retrieves this message |

Line 5552: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

5548: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
5549: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
5550: FND_MSG_PUB.Add;
5551: /*---------------------------------------------------------+
5552: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
5553: | in the message stack. If there is only one message in |
5554: | the stack it retrieves this message |
5555: +---------------------------------------------------------*/
5556: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 5556: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

5552: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
5553: | in the message stack. If there is only one message in |
5554: | the stack it retrieves this message |
5555: +---------------------------------------------------------*/
5556: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
5557: p_count => x_msg_count,
5558: p_data => x_msg_data
5559: );
5560: IF ( G_LEVEL_UNEXPECTED >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 5625: FND_MSG_PUB.initialize;

5621: l_init_msg_list := p_init_msg_list;
5622: END IF;
5623:
5624: IF FND_API.to_Boolean(l_init_msg_list) THEN
5625: FND_MSG_PUB.initialize;
5626: END IF;
5627:
5628: /*-----------------------------------------+
5629: | Populate Global Variable |

Line 5821: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

5817: WHEN FND_API.G_EXC_ERROR THEN
5818: ROLLBACK TO Get_Tax_Distribution_Ccids_PVT;
5819: x_return_status := FND_API.G_RET_STS_ERROR ;
5820: /*---------------------------------------------------------+
5821: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
5822: | in the message stack. If there is only one message in |
5823: | the stack it retrieves this message |
5824: +---------------------------------------------------------*/
5825: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 5825: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

5821: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
5822: | in the message stack. If there is only one message in |
5823: | the stack it retrieves this message |
5824: +---------------------------------------------------------*/
5825: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
5826: p_count => x_msg_count,
5827: p_data => x_msg_data
5828: );
5829:

Line 5837: FND_MSG_PUB.Add;

5833:
5834: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
5835: ROLLBACK TO Get_Tax_Distribution_Ccids_PVT;
5836: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
5837: FND_MSG_PUB.Add;
5838: /*---------------------------------------------------------+
5839: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
5840: | in the message stack. If there is only one message in |
5841: | the stack it retrieves this message |

Line 5839: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

5835: ROLLBACK TO Get_Tax_Distribution_Ccids_PVT;
5836: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
5837: FND_MSG_PUB.Add;
5838: /*---------------------------------------------------------+
5839: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
5840: | in the message stack. If there is only one message in |
5841: | the stack it retrieves this message |
5842: +---------------------------------------------------------*/
5843: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 5843: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

5839: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
5840: | in the message stack. If there is only one message in |
5841: | the stack it retrieves this message |
5842: +---------------------------------------------------------*/
5843: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
5844: p_count => x_msg_count,
5845: p_data => x_msg_data
5846: );
5847: IF ( G_LEVEL_ERROR >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 5855: FND_MSG_PUB.Add;

5851: WHEN OTHERS THEN
5852: ROLLBACK TO Get_Tax_Distribution_Ccids_PVT;
5853: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
5854: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
5855: FND_MSG_PUB.Add;
5856: /*---------------------------------------------------------+
5857: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
5858: | in the message stack. If there is only one message in |
5859: | the stack it retrieves this message |

Line 5857: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

5853: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
5854: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
5855: FND_MSG_PUB.Add;
5856: /*---------------------------------------------------------+
5857: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
5858: | in the message stack. If there is only one message in |
5859: | the stack it retrieves this message |
5860: +---------------------------------------------------------*/
5861: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 5861: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

5857: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
5858: | in the message stack. If there is only one message in |
5859: | the stack it retrieves this message |
5860: +---------------------------------------------------------*/
5861: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
5862: p_count => x_msg_count,
5863: p_data => x_msg_data
5864: );
5865:

Line 5925: FND_MSG_PUB.initialize;

5921: l_init_msg_list := p_init_msg_list;
5922: END IF;
5923:
5924: IF FND_API.to_Boolean(l_init_msg_list) THEN
5925: FND_MSG_PUB.initialize;
5926: END IF;
5927:
5928: /*-----------------------------------------+
5929: | Initialize return status to SUCCESS |

Line 5969: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

5965: WHEN FND_API.G_EXC_ERROR THEN
5966: ROLLBACK TO Update_Tax_Dist_Gl_Date_PVT;
5967: x_return_status := FND_API.G_RET_STS_ERROR ;
5968: /*---------------------------------------------------------+
5969: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
5970: | in the message stack. If there is only one message in |
5971: | the stack it retrieves this message |
5972: +---------------------------------------------------------*/
5973: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 5973: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

5969: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
5970: | in the message stack. If there is only one message in |
5971: | the stack it retrieves this message |
5972: +---------------------------------------------------------*/
5973: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
5974: p_count => x_msg_count,
5975: p_data => x_msg_data
5976: );
5977: IF ( G_LEVEL_ERROR >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 5985: FND_MSG_PUB.Add;

5981: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
5982: ROLLBACK TO Update_Tax_Dist_GL_Date_PVT;
5983: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
5984: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
5985: FND_MSG_PUB.Add;
5986: /*---------------------------------------------------------+
5987: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
5988: | in the message stack. If there is only one message in |
5989: | the stack it retrieves this message |

Line 5987: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

5983: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
5984: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
5985: FND_MSG_PUB.Add;
5986: /*---------------------------------------------------------+
5987: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
5988: | in the message stack. If there is only one message in |
5989: | the stack it retrieves this message |
5990: +---------------------------------------------------------*/
5991: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 5991: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

5987: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
5988: | in the message stack. If there is only one message in |
5989: | the stack it retrieves this message |
5990: +---------------------------------------------------------*/
5991: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
5992: p_count => x_msg_count,
5993: p_data => x_msg_data
5994: );
5995: IF ( G_LEVEL_ERROR >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 6003: FND_MSG_PUB.Add;

5999: WHEN OTHERS THEN
6000: ROLLBACK TO Update_tax_dist_gl_date_PVT;
6001: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
6002: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
6003: FND_MSG_PUB.Add;
6004: /*---------------------------------------------------------+
6005: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
6006: | in the message stack. If there is only one message in |
6007: | the stack it retrieves this message |

Line 6005: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

6001: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
6002: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
6003: FND_MSG_PUB.Add;
6004: /*---------------------------------------------------------+
6005: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
6006: | in the message stack. If there is only one message in |
6007: | the stack it retrieves this message |
6008: +---------------------------------------------------------*/
6009: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 6009: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

6005: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
6006: | in the message stack. If there is only one message in |
6007: | the stack it retrieves this message |
6008: +---------------------------------------------------------*/
6009: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
6010: p_count => x_msg_count,
6011: p_data => x_msg_data
6012: );
6013: IF ( G_LEVEL_UNEXPECTED >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 6075: FND_MSG_PUB.initialize;

6071: l_init_msg_list := p_init_msg_list;
6072: END IF;
6073:
6074: IF FND_API.to_Boolean(l_init_msg_list) THEN
6075: FND_MSG_PUB.initialize;
6076: END IF;
6077:
6078: /*-----------------------------------------+
6079: | Initialize return status to SUCCESS |

Line 6097: FND_MSG_PUB.Add;

6093: | Missing Currency Conversion Rate |
6094: +---------------------------------------------*/
6095: IF p_curr_conv_rate is NULL THEN
6096: FND_MESSAGE.SET_NAME('ZX','ZX_CURRENCY_CONVERSION_RATE_REQD');
6097: FND_MSG_PUB.Add;
6098: IF ( G_LEVEL_STATEMENT >= G_CURRENT_RUNTIME_LEVEL) THEN
6099: FND_LOG.STRING(G_LEVEL_STATEMENT,G_MODULE_NAME||l_api_name,G_PKG_NAME||': '||l_api_name||
6100: 'Currency conversion rate is passed as null');
6101: END IF;

Line 6110: FND_MSG_PUB.Add;

6106: | Missing Currency Conversion Date |
6107: +---------------------------------------------*/
6108: IF p_curr_conv_date is NULL THEN
6109: FND_MESSAGE.SET_NAME('ZX','ZX_CURRENCY_CONVERSION_DATE_REQD');
6110: FND_MSG_PUB.Add;
6111: IF ( G_LEVEL_STATEMENT >= G_CURRENT_RUNTIME_LEVEL) THEN
6112: FND_LOG.STRING(G_LEVEL_STATEMENT,G_MODULE_NAME||l_api_name,G_PKG_NAME||': '||l_api_name||
6113: 'Currency conversion date is passed as null');
6114: END IF;

Line 6123: FND_MSG_PUB.Add;

6119: | Missing Currency Conversion Type |
6120: +---------------------------------------------*/
6121: IF p_curr_conv_type is NULL THEN
6122: FND_MESSAGE.SET_NAME('ZX','ZX_CURRENCY_CONVERSION_TYPE_REQD');
6123: FND_MSG_PUB.Add;
6124: IF ( G_LEVEL_STATEMENT >= G_CURRENT_RUNTIME_LEVEL) THEN
6125: FND_LOG.STRING(G_LEVEL_STATEMENT,G_MODULE_NAME||l_api_name,G_PKG_NAME||': '||l_api_name||
6126: 'Currency conversion type is passed as null');
6127: END IF;

Line 6203: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

6199: WHEN FND_API.G_EXC_ERROR THEN
6200: ROLLBACK TO Update_Exchange_Rate_PVT;
6201: x_return_status := FND_API.G_RET_STS_ERROR ;
6202: /*---------------------------------------------------------+
6203: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
6204: | in the message stack. If there is only one message in |
6205: | the stack it retrieves this message |
6206: +---------------------------------------------------------*/
6207: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 6207: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

6203: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
6204: | in the message stack. If there is only one message in |
6205: | the stack it retrieves this message |
6206: +---------------------------------------------------------*/
6207: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
6208: p_count => x_msg_count,
6209: p_data => x_msg_data
6210: );
6211:

Line 6220: FND_MSG_PUB.Add;

6216: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
6217: ROLLBACK TO Update_Exchange_Rate_PVT;
6218: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
6219: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
6220: FND_MSG_PUB.Add;
6221: /*---------------------------------------------------------+
6222: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
6223: | in the message stack. If there is only one message in |
6224: | the stack it retrieves this message |

Line 6222: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

6218: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
6219: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
6220: FND_MSG_PUB.Add;
6221: /*---------------------------------------------------------+
6222: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
6223: | in the message stack. If there is only one message in |
6224: | the stack it retrieves this message |
6225: +---------------------------------------------------------*/
6226: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 6226: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

6222: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
6223: | in the message stack. If there is only one message in |
6224: | the stack it retrieves this message |
6225: +---------------------------------------------------------*/
6226: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
6227: p_count => x_msg_count,
6228: p_data => x_msg_data
6229: );
6230: IF ( G_LEVEL_ERROR >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 6238: FND_MSG_PUB.Add;

6234: WHEN OTHERS THEN
6235: ROLLBACK TO Update_Exchange_Rate_PVT;
6236: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
6237: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
6238: FND_MSG_PUB.Add;
6239: /*---------------------------------------------------------+
6240: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
6241: | in the message stack. If there is only one message in |
6242: | the stack it retrieves this message |

Line 6240: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

6236: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
6237: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
6238: FND_MSG_PUB.Add;
6239: /*---------------------------------------------------------+
6240: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
6241: | in the message stack. If there is only one message in |
6242: | the stack it retrieves this message |
6243: +---------------------------------------------------------*/
6244: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 6244: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

6240: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
6241: | in the message stack. If there is only one message in |
6242: | the stack it retrieves this message |
6243: +---------------------------------------------------------*/
6244: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
6245: p_count => x_msg_count,
6246: p_data => x_msg_data
6247: );
6248:

Line 6315: FND_MSG_PUB.initialize;

6311: l_init_msg_list := p_init_msg_list;
6312: END IF;
6313:
6314: IF FND_API.to_Boolean(l_init_msg_list) THEN
6315: FND_MSG_PUB.initialize;
6316: END IF;
6317:
6318: /*-----------------------------------------+
6319: | Initialize return status to SUCCESS |

Line 6415: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

6411: WHEN FND_API.G_EXC_ERROR THEN
6412: ROLLBACK TO discard_tax_only_lines_PVT;
6413: x_return_status := FND_API.G_RET_STS_ERROR ;
6414: /*---------------------------------------------------------+
6415: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
6416: | in the message stack. If there is only one message in |
6417: | the stack it retrieves this message |
6418: +---------------------------------------------------------*/
6419: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 6419: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

6415: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
6416: | in the message stack. If there is only one message in |
6417: | the stack it retrieves this message |
6418: +---------------------------------------------------------*/
6419: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
6420: p_count => x_msg_count,
6421: p_data => x_msg_data
6422: );
6423: IF ( G_LEVEL_ERROR >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 6431: FND_MSG_PUB.Add;

6427: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
6428: ROLLBACK TO discard_tax_only_lines_PVT;
6429: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
6430: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
6431: FND_MSG_PUB.Add;
6432: /*---------------------------------------------------------+
6433: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
6434: | in the message stack. If there is only one message in |
6435: | the stack it retrieves this message |

Line 6433: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

6429: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
6430: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
6431: FND_MSG_PUB.Add;
6432: /*---------------------------------------------------------+
6433: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
6434: | in the message stack. If there is only one message in |
6435: | the stack it retrieves this message |
6436: +---------------------------------------------------------*/
6437: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 6437: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

6433: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
6434: | in the message stack. If there is only one message in |
6435: | the stack it retrieves this message |
6436: +---------------------------------------------------------*/
6437: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
6438: p_count => x_msg_count,
6439: p_data => x_msg_data
6440: );
6441: IF ( G_LEVEL_ERROR >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 6449: FND_MSG_PUB.Add;

6445: WHEN OTHERS THEN
6446: ROLLBACK TO discard_tax_only_lines_PVT;
6447: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
6448: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
6449: FND_MSG_PUB.Add;
6450: /*---------------------------------------------------------+
6451: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
6452: | in the message stack. If there is only one message in |
6453: | the stack it retrieves this message |

Line 6451: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

6447: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
6448: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
6449: FND_MSG_PUB.Add;
6450: /*---------------------------------------------------------+
6451: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
6452: | in the message stack. If there is only one message in |
6453: | the stack it retrieves this message |
6454: +---------------------------------------------------------*/
6455: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 6455: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

6451: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
6452: | in the message stack. If there is only one message in |
6453: | the stack it retrieves this message |
6454: +---------------------------------------------------------*/
6455: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
6456: p_count => x_msg_count,
6457: p_data => x_msg_data
6458: );
6459: IF ( G_LEVEL_UNEXPECTED >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 6519: FND_MSG_PUB.initialize;

6515: l_init_msg_list := p_init_msg_list;
6516: END IF;
6517:
6518: IF FND_API.to_Boolean(l_init_msg_list) THEN
6519: FND_MSG_PUB.initialize;
6520: END IF;
6521:
6522: /*-----------------------------------------+
6523: | Initialize return status to SUCCESS |

Line 6595: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

6591: WHEN FND_API.G_EXC_ERROR THEN
6592: ROLLBACK TO Validate_Document_PVT;
6593: x_return_status := FND_API.G_RET_STS_ERROR ;
6594: /*---------------------------------------------------------+
6595: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
6596: | in the message stack. If there is only one message in |
6597: | the stack it retrieves this message |
6598: +---------------------------------------------------------*/
6599: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 6599: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

6595: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
6596: | in the message stack. If there is only one message in |
6597: | the stack it retrieves this message |
6598: +---------------------------------------------------------*/
6599: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
6600: p_count => x_msg_count,
6601: p_data => x_msg_data
6602: );
6603: IF ( G_LEVEL_ERROR >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 6611: FND_MSG_PUB.Add;

6607: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
6608: ROLLBACK TO Validate_Document_PVT;
6609: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
6610: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
6611: FND_MSG_PUB.Add;
6612: /*---------------------------------------------------------+
6613: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
6614: | in the message stack. If there is only one message in |
6615: | the stack it retrieves this message |

Line 6613: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

6609: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
6610: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
6611: FND_MSG_PUB.Add;
6612: /*---------------------------------------------------------+
6613: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
6614: | in the message stack. If there is only one message in |
6615: | the stack it retrieves this message |
6616: +---------------------------------------------------------*/
6617: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 6617: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

6613: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
6614: | in the message stack. If there is only one message in |
6615: | the stack it retrieves this message |
6616: +---------------------------------------------------------*/
6617: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
6618: p_count => x_msg_count,
6619: p_data => x_msg_data
6620: );
6621: IF ( G_LEVEL_ERROR >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 6630: FND_MSG_PUB.Add;

6626: WHEN OTHERS THEN
6627: ROLLBACK TO Validate_Document_PVT;
6628: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
6629: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
6630: FND_MSG_PUB.Add;
6631: /*---------------------------------------------------------+
6632: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
6633: | in the message stack. If there is only one message in |
6634: | the stack it retrieves this message |

Line 6632: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

6628: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
6629: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
6630: FND_MSG_PUB.Add;
6631: /*---------------------------------------------------------+
6632: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
6633: | in the message stack. If there is only one message in |
6634: | the stack it retrieves this message |
6635: +---------------------------------------------------------*/
6636: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 6636: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

6632: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
6633: | in the message stack. If there is only one message in |
6634: | the stack it retrieves this message |
6635: +---------------------------------------------------------*/
6636: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
6637: p_count => x_msg_count,
6638: p_data => x_msg_data
6639: );
6640:

Line 6733: FND_MSG_PUB.initialize;

6729: l_init_msg_list := p_init_msg_list;
6730: END IF;
6731:
6732: IF FND_API.to_Boolean(l_init_msg_list) THEN
6733: FND_MSG_PUB.initialize;
6734: END IF;
6735:
6736: /*-----------------------------------------+
6737: | Initialize return status to SUCCESS |

Line 6785: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

6781: WHEN FND_API.G_EXC_ERROR THEN
6782: ROLLBACK TO Validate_Document_PVT;
6783: x_return_status := FND_API.G_RET_STS_ERROR ;
6784: /*---------------------------------------------------------+
6785: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
6786: | in the message stack. If there is only one message in |
6787: | the stack it retrieves this message |
6788: +---------------------------------------------------------*/
6789: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 6789: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

6785: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
6786: | in the message stack. If there is only one message in |
6787: | the stack it retrieves this message |
6788: +---------------------------------------------------------*/
6789: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
6790: p_count => x_msg_count,
6791: p_data => x_msg_data
6792: );
6793: IF ( G_LEVEL_ERROR >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 6801: FND_MSG_PUB.Add;

6797: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
6798: ROLLBACK TO Validate_Document_PVT;
6799: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
6800: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
6801: FND_MSG_PUB.Add;
6802: /*---------------------------------------------------------+
6803: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
6804: | in the message stack. If there is only one message in |
6805: | the stack it retrieves this message |

Line 6803: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

6799: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
6800: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
6801: FND_MSG_PUB.Add;
6802: /*---------------------------------------------------------+
6803: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
6804: | in the message stack. If there is only one message in |
6805: | the stack it retrieves this message |
6806: +---------------------------------------------------------*/
6807: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 6807: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

6803: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
6804: | in the message stack. If there is only one message in |
6805: | the stack it retrieves this message |
6806: +---------------------------------------------------------*/
6807: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
6808: p_count => x_msg_count,
6809: p_data => x_msg_data
6810: );
6811: IF ( G_LEVEL_ERROR >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 6820: FND_MSG_PUB.Add;

6816: WHEN OTHERS THEN
6817: ROLLBACK TO Validate_Document_PVT;
6818: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
6819: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
6820: FND_MSG_PUB.Add;
6821: /*---------------------------------------------------------+
6822: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
6823: | in the message stack. If there is only one message in |
6824: | the stack it retrieves this message |

Line 6822: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

6818: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
6819: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
6820: FND_MSG_PUB.Add;
6821: /*---------------------------------------------------------+
6822: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
6823: | in the message stack. If there is only one message in |
6824: | the stack it retrieves this message |
6825: +---------------------------------------------------------*/
6826: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 6826: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

6822: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
6823: | in the message stack. If there is only one message in |
6824: | the stack it retrieves this message |
6825: +---------------------------------------------------------*/
6826: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
6827: p_count => x_msg_count,
6828: p_data => x_msg_data
6829: );
6830:

Line 6895: FND_MSG_PUB.initialize;

6891: l_init_msg_list := p_init_msg_list;
6892: END IF;
6893:
6894: IF FND_API.to_Boolean(l_init_msg_list) THEN
6895: FND_MSG_PUB.initialize;
6896: END IF;
6897:
6898:
6899: /*-----------------------------------------+

Line 6943: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

6939: WHEN FND_API.G_EXC_ERROR THEN
6940: ROLLBACK TO Get_Default_Tax_Line_Attrs_PVT;
6941: x_return_status := FND_API.G_RET_STS_ERROR ;
6942: /*---------------------------------------------------------+
6943: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
6944: | in the message stack. If there is only one message in |
6945: | the stack it retrieves this message |
6946: +---------------------------------------------------------*/
6947: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 6947: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

6943: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
6944: | in the message stack. If there is only one message in |
6945: | the stack it retrieves this message |
6946: +---------------------------------------------------------*/
6947: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
6948: p_count => x_msg_count,
6949: p_data => x_msg_data
6950: );
6951: IF ( G_LEVEL_ERROR >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 6959: FND_MSG_PUB.Add;

6955: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
6956: ROLLBACK TO Get_Default_Tax_Line_Attrs_PVT;
6957: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
6958: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
6959: FND_MSG_PUB.Add;
6960: /*---------------------------------------------------------+
6961: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
6962: | in the message stack. If there is only one message in |
6963: | the stack it retrieves this message |

Line 6961: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

6957: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
6958: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
6959: FND_MSG_PUB.Add;
6960: /*---------------------------------------------------------+
6961: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
6962: | in the message stack. If there is only one message in |
6963: | the stack it retrieves this message |
6964: +---------------------------------------------------------*/
6965: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 6965: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

6961: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
6962: | in the message stack. If there is only one message in |
6963: | the stack it retrieves this message |
6964: +---------------------------------------------------------*/
6965: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
6966: p_count => x_msg_count,
6967: p_data => x_msg_data
6968: );
6969: IF ( G_LEVEL_ERROR >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 6977: FND_MSG_PUB.Add;

6973: WHEN OTHERS THEN
6974: ROLLBACK TO Get_Default_Tax_Line_Attrs_PVT;
6975: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
6976: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
6977: FND_MSG_PUB.Add;
6978: /*---------------------------------------------------------+
6979: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
6980: | in the message stack. If there is only one message in |
6981: | the stack it retrieves this message |

Line 6979: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

6975: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
6976: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
6977: FND_MSG_PUB.Add;
6978: /*---------------------------------------------------------+
6979: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
6980: | in the message stack. If there is only one message in |
6981: | the stack it retrieves this message |
6982: +---------------------------------------------------------*/
6983: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 6983: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

6979: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
6980: | in the message stack. If there is only one message in |
6981: | the stack it retrieves this message |
6982: +---------------------------------------------------------*/
6983: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
6984: p_count => x_msg_count,
6985: p_data => x_msg_data
6986: );
6987:

Line 7129: FND_MSG_PUB.initialize;

7125: l_init_msg_list := p_init_msg_list;
7126: END IF;
7127:
7128: IF FND_API.to_Boolean(l_init_msg_list) THEN
7129: FND_MSG_PUB.initialize;
7130: END IF;
7131:
7132: /*-----------------------------------------+
7133: | Initialize return status to SUCCESS |

Line 7399: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

7395: WHEN FND_API.G_EXC_ERROR THEN
7396: ROLLBACK TO Get_Default_Tax_Det_Attrs_PVT;
7397: x_return_status := FND_API.G_RET_STS_ERROR ;
7398: /*---------------------------------------------------------+
7399: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
7400: | in the message stack. If there is only one message in |
7401: | the stack it retrieves this message |
7402: +---------------------------------------------------------*/
7403: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 7403: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

7399: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
7400: | in the message stack. If there is only one message in |
7401: | the stack it retrieves this message |
7402: +---------------------------------------------------------*/
7403: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
7404: p_count => x_msg_count,
7405: p_data => x_msg_data
7406: );
7407: IF ( G_LEVEL_ERROR >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 7415: FND_MSG_PUB.Add;

7411: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
7412: ROLLBACK TO Get_Default_Tax_Det_Attrs_PVT;
7413: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
7414: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
7415: FND_MSG_PUB.Add;
7416: /*---------------------------------------------------------+
7417: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
7418: | in the message stack. If there is only one message in |
7419: | the stack it retrieves this message |

Line 7417: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

7413: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
7414: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
7415: FND_MSG_PUB.Add;
7416: /*---------------------------------------------------------+
7417: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
7418: | in the message stack. If there is only one message in |
7419: | the stack it retrieves this message |
7420: +---------------------------------------------------------*/
7421: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 7421: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

7417: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
7418: | in the message stack. If there is only one message in |
7419: | the stack it retrieves this message |
7420: +---------------------------------------------------------*/
7421: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
7422: p_count => x_msg_count,
7423: p_data => x_msg_data
7424: );
7425:

Line 7434: FND_MSG_PUB.Add;

7430: WHEN OTHERS THEN
7431: ROLLBACK TO Get_Default_Tax_Det_Attrs_PVT;
7432: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
7433: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
7434: FND_MSG_PUB.Add;
7435: /*---------------------------------------------------------+
7436: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
7437: | in the message stack. If there is only one message in |
7438: | the stack it retrieves this message |

Line 7436: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

7432: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
7433: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
7434: FND_MSG_PUB.Add;
7435: /*---------------------------------------------------------+
7436: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
7437: | in the message stack. If there is only one message in |
7438: | the stack it retrieves this message |
7439: +---------------------------------------------------------*/
7440: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 7440: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

7436: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
7437: | in the message stack. If there is only one message in |
7438: | the stack it retrieves this message |
7439: +---------------------------------------------------------*/
7440: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
7441: p_count => x_msg_count,
7442: p_data => x_msg_data
7443: );
7444: IF ( G_LEVEL_UNEXPECTED >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 7519: FND_MSG_PUB.initialize;

7515: l_init_msg_list := p_init_msg_list;
7516: END IF;
7517:
7518: IF FND_API.to_Boolean(l_init_msg_list) THEN
7519: FND_MSG_PUB.initialize;
7520: END IF;
7521:
7522: /*-----------------------------------------+
7523: | Initialize return status to SUCCESS |

Line 7696: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

7692: WHEN FND_API.G_EXC_ERROR THEN
7693: ROLLBACK TO Get_Default_Tax_Det_Attrs_PVT;
7694: x_return_status := FND_API.G_RET_STS_ERROR ;
7695: /*---------------------------------------------------------+
7696: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
7697: | in the message stack. If there is only one message in |
7698: | the stack it retrieves this message |
7699: +---------------------------------------------------------*/
7700: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 7700: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

7696: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
7697: | in the message stack. If there is only one message in |
7698: | the stack it retrieves this message |
7699: +---------------------------------------------------------*/
7700: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
7701: p_count => x_msg_count,
7702: p_data => x_msg_data
7703: );
7704: IF ( G_LEVEL_ERROR >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 7712: FND_MSG_PUB.Add;

7708: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
7709: ROLLBACK TO Get_Default_Tax_Det_Attrs_PVT;
7710: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
7711: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
7712: FND_MSG_PUB.Add;
7713: /*---------------------------------------------------------+
7714: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
7715: | in the message stack. If there is only one message in |
7716: | the stack it retrieves this message |

Line 7714: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

7710: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
7711: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
7712: FND_MSG_PUB.Add;
7713: /*---------------------------------------------------------+
7714: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
7715: | in the message stack. If there is only one message in |
7716: | the stack it retrieves this message |
7717: +---------------------------------------------------------*/
7718: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 7718: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

7714: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
7715: | in the message stack. If there is only one message in |
7716: | the stack it retrieves this message |
7717: +---------------------------------------------------------*/
7718: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
7719: p_count => x_msg_count,
7720: p_data => x_msg_data
7721: );
7722:

Line 7731: FND_MSG_PUB.Add;

7727: WHEN OTHERS THEN
7728: ROLLBACK TO Get_Default_Tax_Det_Attrs_PVT;
7729: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
7730: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
7731: FND_MSG_PUB.Add;
7732: /*---------------------------------------------------------+
7733: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
7734: | in the message stack. If there is only one message in |
7735: | the stack it retrieves this message |

Line 7733: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

7729: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
7730: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
7731: FND_MSG_PUB.Add;
7732: /*---------------------------------------------------------+
7733: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
7734: | in the message stack. If there is only one message in |
7735: | the stack it retrieves this message |
7736: +---------------------------------------------------------*/
7737: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 7737: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

7733: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
7734: | in the message stack. If there is only one message in |
7735: | the stack it retrieves this message |
7736: +---------------------------------------------------------*/
7737: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
7738: p_count => x_msg_count,
7739: p_data => x_msg_data
7740: );
7741: IF ( G_LEVEL_UNEXPECTED >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 7804: FND_MSG_PUB.initialize;

7800: l_init_msg_list := p_init_msg_list;
7801: END IF;
7802:
7803: IF FND_API.to_Boolean(l_init_msg_list) THEN
7804: FND_MSG_PUB.initialize;
7805: END IF;
7806:
7807: /*-----------------------------------------+
7808: | Initialize return status to SUCCESS |

Line 7840: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

7836: END IF;
7837: END IF;
7838:
7839: /*---------------------------------------------------------+
7840: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
7841: | in the message stack. If there is only one message in |
7842: | the stack it retrieves this message |
7843: +---------------------------------------------------------*/
7844: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 7844: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

7840: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
7841: | in the message stack. If there is only one message in |
7842: | the stack it retrieves this message |
7843: +---------------------------------------------------------*/
7844: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
7845: p_count => x_msg_count,
7846: p_data => x_msg_data
7847: );
7848:

Line 7858: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

7854: WHEN FND_API.G_EXC_ERROR THEN
7855: ROLLBACK TO Set_Tax_Security_Context_PVT;
7856: x_return_status := FND_API.G_RET_STS_ERROR ;
7857: /*---------------------------------------------------------+
7858: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
7859: | in the message stack. If there is only one message in |
7860: | the stack it retrieves this message |
7861: +---------------------------------------------------------*/
7862: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 7862: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

7858: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
7859: | in the message stack. If there is only one message in |
7860: | the stack it retrieves this message |
7861: +---------------------------------------------------------*/
7862: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
7863: p_count => x_msg_count,
7864: p_data => x_msg_data
7865: );
7866:

Line 7875: FND_MSG_PUB.Add;

7871: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
7872: ROLLBACK TO Set_Tax_Security_Context_PVT;
7873: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
7874: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
7875: FND_MSG_PUB.Add;
7876: /*---------------------------------------------------------+
7877: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
7878: | in the message stack. If there is only one message in |
7879: | the stack it retrieves this message |

Line 7877: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

7873: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
7874: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
7875: FND_MSG_PUB.Add;
7876: /*---------------------------------------------------------+
7877: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
7878: | in the message stack. If there is only one message in |
7879: | the stack it retrieves this message |
7880: +---------------------------------------------------------*/
7881: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 7881: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

7877: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
7878: | in the message stack. If there is only one message in |
7879: | the stack it retrieves this message |
7880: +---------------------------------------------------------*/
7881: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
7882: p_count => x_msg_count,
7883: p_data => x_msg_data
7884: );
7885:

Line 7894: FND_MSG_PUB.Add;

7890: WHEN OTHERS THEN
7891: ROLLBACK TO set_tax_security_context_PVT;
7892: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
7893: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
7894: FND_MSG_PUB.Add;
7895: /*---------------------------------------------------------+
7896: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
7897: | in the message stack. If there is only one message in |
7898: | the stack it retrieves this message |

Line 7896: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

7892: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
7893: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
7894: FND_MSG_PUB.Add;
7895: /*---------------------------------------------------------+
7896: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
7897: | in the message stack. If there is only one message in |
7898: | the stack it retrieves this message |
7899: +---------------------------------------------------------*/
7900: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 7900: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

7896: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
7897: | in the message stack. If there is only one message in |
7898: | the stack it retrieves this message |
7899: +---------------------------------------------------------*/
7900: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
7901: p_count => x_msg_count,
7902: p_data => x_msg_data
7903: );
7904: IF ( G_LEVEL_UNEXPECTED >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 7967: FND_MSG_PUB.initialize;

7963: l_init_msg_list := p_init_msg_list;
7964: END IF;
7965:
7966: IF FND_API.to_Boolean(l_init_msg_list) THEN
7967: FND_MSG_PUB.initialize;
7968: END IF;
7969:
7970: /*-----------------------------------------+
7971: | Initialize return status to SUCCESS |

Line 8002: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

7998: END IF;
7999: END IF;
8000:
8001: /*---------------------------------------------------------+
8002: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
8003: | in the message stack. If there is only one message in |
8004: | the stack it retrieves this message |
8005: +---------------------------------------------------------*/
8006: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 8006: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

8002: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
8003: | in the message stack. If there is only one message in |
8004: | the stack it retrieves this message |
8005: +---------------------------------------------------------*/
8006: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
8007: p_count => x_msg_count,
8008: p_data => x_msg_data
8009: );
8010:

Line 8020: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

8016: WHEN FND_API.G_EXC_ERROR THEN
8017: ROLLBACK TO Set_Tax_Security_Context_PVT;
8018: x_return_status := FND_API.G_RET_STS_ERROR ;
8019: /*---------------------------------------------------------+
8020: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
8021: | in the message stack. If there is only one message in |
8022: | the stack it retrieves this message |
8023: +---------------------------------------------------------*/
8024: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 8024: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

8020: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
8021: | in the message stack. If there is only one message in |
8022: | the stack it retrieves this message |
8023: +---------------------------------------------------------*/
8024: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
8025: p_count => x_msg_count,
8026: p_data => x_msg_data
8027: );
8028:

Line 8037: FND_MSG_PUB.Add;

8033: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
8034: ROLLBACK TO Set_Tax_Security_Context_PVT;
8035: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
8036: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
8037: FND_MSG_PUB.Add;
8038: /*---------------------------------------------------------+
8039: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
8040: | in the message stack. If there is only one message in |
8041: | the stack it retrieves this message |

Line 8039: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

8035: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
8036: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
8037: FND_MSG_PUB.Add;
8038: /*---------------------------------------------------------+
8039: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
8040: | in the message stack. If there is only one message in |
8041: | the stack it retrieves this message |
8042: +---------------------------------------------------------*/
8043: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 8043: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

8039: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
8040: | in the message stack. If there is only one message in |
8041: | the stack it retrieves this message |
8042: +---------------------------------------------------------*/
8043: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
8044: p_count => x_msg_count,
8045: p_data => x_msg_data
8046: );
8047:

Line 8056: FND_MSG_PUB.Add;

8052: WHEN OTHERS THEN
8053: ROLLBACK TO set_tax_security_context_PVT;
8054: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
8055: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
8056: FND_MSG_PUB.Add;
8057: /*---------------------------------------------------------+
8058: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
8059: | in the message stack. If there is only one message in |
8060: | the stack it retrieves this message |

Line 8058: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

8054: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
8055: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
8056: FND_MSG_PUB.Add;
8057: /*---------------------------------------------------------+
8058: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
8059: | in the message stack. If there is only one message in |
8060: | the stack it retrieves this message |
8061: +---------------------------------------------------------*/
8062: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 8062: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

8058: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
8059: | in the message stack. If there is only one message in |
8060: | the stack it retrieves this message |
8061: +---------------------------------------------------------*/
8062: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
8063: p_count => x_msg_count,
8064: p_data => x_msg_data
8065: );
8066: IF ( G_LEVEL_UNEXPECTED >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 8128: FND_MSG_PUB.initialize;

8124: l_init_msg_list := p_init_msg_list;
8125: END IF;
8126:
8127: IF FND_API.to_Boolean(l_init_msg_list) THEN
8128: FND_MSG_PUB.initialize;
8129: END IF;
8130:
8131: /*-----------------------------------------+
8132: | Initialize return status to SUCCESS |

Line 8235: FND_MSG_PUB.Add;

8231: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
8232: ROLLBACK TO Validate_And_Default_Tax_Attr;
8233: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
8234: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
8235: FND_MSG_PUB.Add;
8236: /*---------------------------------------------------------+
8237: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
8238: | in the message stack. If there is only one message in |
8239: | the stack it retrieves this message |

Line 8237: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

8233: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
8234: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
8235: FND_MSG_PUB.Add;
8236: /*---------------------------------------------------------+
8237: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
8238: | in the message stack. If there is only one message in |
8239: | the stack it retrieves this message |
8240: +---------------------------------------------------------*/
8241: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 8241: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

8237: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
8238: | in the message stack. If there is only one message in |
8239: | the stack it retrieves this message |
8240: +---------------------------------------------------------*/
8241: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
8242: p_count => x_msg_count,
8243: p_data => x_msg_data
8244: );
8245:

Line 8254: FND_MSG_PUB.Add;

8250: WHEN OTHERS THEN
8251: ROLLBACK TO Validate_And_Default_Tax_Attr;
8252: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
8253: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
8254: FND_MSG_PUB.Add;
8255: /*---------------------------------------------------------+
8256: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
8257: | in the message stack. If there is only one message in |
8258: | the stack it retrieves this message |

Line 8256: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

8252: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
8253: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
8254: FND_MSG_PUB.Add;
8255: /*---------------------------------------------------------+
8256: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
8257: | in the message stack. If there is only one message in |
8258: | the stack it retrieves this message |
8259: +---------------------------------------------------------*/
8260: IF ( G_LEVEL_UNEXPECTED >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 8331: FND_MSG_PUB.Add();

8327: FND_LOG.STRING(G_LEVEL_PROCEDURE,G_MODULE_NAME||l_api_name||'.BEGIN','ZX_API_PUB: '||l_api_name||'()+');
8328: END IF;
8329: --Add unexpected errors to fnd_stack
8330: IF p_context_info_rec.application_id is null THEN
8331: FND_MSG_PUB.Add();
8332: END IF;
8333:
8334: IF G_DATA_TRANSFER_MODE = 'PLS' OR
8335: G_DATA_TRANSFER_MODE = 'WIN' THEN

Line 8341: FND_MSG_PUB.Add();

8337: since message is already in stack.*/
8338: IF G_EXTERNAL_API_CALL = 'Y' THEN
8339: G_EXTERNAL_API_CALL := 'N';
8340: ELSE
8341: FND_MSG_PUB.Add();
8342: END IF;
8343: ELSIF G_DATA_TRANSFER_MODE = 'TAB' THEN
8344: l_count:= errors_tbl.application_id.COUNT;
8345: IF G_EXTERNAL_API_CALL = 'Y' THEN

Line 8347: l_mesg := FND_MSG_PUB.Get(FND_MSG_PUB.G_NEXT, FND_API.G_FALSE);

8343: ELSIF G_DATA_TRANSFER_MODE = 'TAB' THEN
8344: l_count:= errors_tbl.application_id.COUNT;
8345: IF G_EXTERNAL_API_CALL = 'Y' THEN
8346: LOOP
8347: l_mesg := FND_MSG_PUB.Get(FND_MSG_PUB.G_NEXT, FND_API.G_FALSE);
8348: IF l_mesg IS NULL THEN
8349: EXIT;
8350: ELSE
8351: errors_tbl.application_id(l_count+1) := p_context_info_rec.application_id;

Line 8518: FND_MSG_PUB.initialize;

8514: l_init_msg_list := p_init_msg_list;
8515: END IF;
8516:
8517: IF FND_API.to_Boolean(l_init_msg_list) THEN
8518: FND_MSG_PUB.initialize;
8519: END IF;
8520:
8521: /*-----------------------------------------+
8522: | Initialize return status to SUCCESS |

Line 8572: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

8568: -- Commented rollback as per bug 5395191
8569: -- ROLLBACK TO Get_Default_Tax_Reg_PVT;
8570: x_return_status := FND_API.G_RET_STS_ERROR ;
8571: /*---------------------------------------------------------+
8572: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
8573: | in the message stack. If there is only one message in |
8574: | the stack it retrieves this message |
8575: +---------------------------------------------------------*/
8576: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 8576: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

8572: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
8573: | in the message stack. If there is only one message in |
8574: | the stack it retrieves this message |
8575: +---------------------------------------------------------*/
8576: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
8577: p_count => x_msg_count,
8578: p_data => x_msg_data
8579: );
8580: IF ( G_LEVEL_ERROR >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 8589: FND_MSG_PUB.Add;

8585: -- Commented rollback as per bug 5395191
8586: -- ROLLBACK TO Get_Default_Tax_Reg_PVT;
8587: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
8588: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
8589: FND_MSG_PUB.Add;
8590: /*---------------------------------------------------------+
8591: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
8592: | in the message stack. If there is only one message in |
8593: | the stack it retrieves this message |

Line 8591: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

8587: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
8588: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
8589: FND_MSG_PUB.Add;
8590: /*---------------------------------------------------------+
8591: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
8592: | in the message stack. If there is only one message in |
8593: | the stack it retrieves this message |
8594: +---------------------------------------------------------*/
8595: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 8595: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

8591: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
8592: | in the message stack. If there is only one message in |
8593: | the stack it retrieves this message |
8594: +---------------------------------------------------------*/
8595: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
8596: p_count => x_msg_count,
8597: p_data => x_msg_data
8598: );
8599: IF ( G_LEVEL_ERROR >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 8608: FND_MSG_PUB.Add;

8604: -- Commented rollback as per bug 5395191
8605: -- ROLLBACK TO Get_Default_Tax_Reg_PVT;
8606: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
8607: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
8608: FND_MSG_PUB.Add;
8609: /*---------------------------------------------------------+
8610: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
8611: | in the message stack. If there is only one message in |
8612: | the stack it retrieves this message |

Line 8610: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

8606: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
8607: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
8608: FND_MSG_PUB.Add;
8609: /*---------------------------------------------------------+
8610: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
8611: | in the message stack. If there is only one message in |
8612: | the stack it retrieves this message |
8613: +---------------------------------------------------------*/
8614: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 8614: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

8610: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
8611: | in the message stack. If there is only one message in |
8612: | the stack it retrieves this message |
8613: +---------------------------------------------------------*/
8614: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
8615: p_count => x_msg_count,
8616: p_data => x_msg_data
8617: );
8618: IF ( G_LEVEL_UNEXPECTED >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 8682: FND_MSG_PUB.initialize;

8678: l_init_msg_list := p_init_msg_list;
8679: END IF;
8680:
8681: IF FND_API.to_Boolean(l_init_msg_list) THEN
8682: FND_MSG_PUB.initialize;
8683: END IF;
8684:
8685: /*-----------------------------------------+
8686: | Initialize return status to SUCCESS |

Line 8940: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

8936: WHEN FND_API.G_EXC_ERROR THEN
8937: ROLLBACK TO Insert_Line_Det_Factors_PVT;
8938: x_return_status := FND_API.G_RET_STS_ERROR ;
8939: /*---------------------------------------------------------+
8940: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
8941: | in the message stack. If there is only one message in |
8942: | the stack it retrieves this message |
8943: +---------------------------------------------------------*/
8944: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 8944: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

8940: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
8941: | in the message stack. If there is only one message in |
8942: | the stack it retrieves this message |
8943: +---------------------------------------------------------*/
8944: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
8945: p_count => x_msg_count,
8946: p_data => x_msg_data
8947: );
8948:

Line 8957: FND_MSG_PUB.Add;

8953: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
8954: ROLLBACK TO Insert_Line_Det_Factors_PVT;
8955: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
8956: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
8957: FND_MSG_PUB.Add;
8958: /*---------------------------------------------------------+
8959: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
8960: | in the message stack. If there is only one message in |
8961: | the stack it retrieves this message |

Line 8959: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

8955: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
8956: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
8957: FND_MSG_PUB.Add;
8958: /*---------------------------------------------------------+
8959: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
8960: | in the message stack. If there is only one message in |
8961: | the stack it retrieves this message |
8962: +---------------------------------------------------------*/
8963: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 8963: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

8959: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
8960: | in the message stack. If there is only one message in |
8961: | the stack it retrieves this message |
8962: +---------------------------------------------------------*/
8963: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
8964: p_count => x_msg_count,
8965: p_data => x_msg_data
8966: );
8967: IF ( G_LEVEL_ERROR >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 8980: FND_MSG_PUB.Add;

8976: ELSE
8977: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
8978: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
8979: END IF;
8980: FND_MSG_PUB.Add;
8981: /*---------------------------------------------------------+
8982: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
8983: | in the message stack. If there is only one message in |
8984: | the stack it retrieves this message |

Line 8982: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

8978: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
8979: END IF;
8980: FND_MSG_PUB.Add;
8981: /*---------------------------------------------------------+
8982: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
8983: | in the message stack. If there is only one message in |
8984: | the stack it retrieves this message |
8985: +---------------------------------------------------------*/
8986: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 8986: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

8982: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
8983: | in the message stack. If there is only one message in |
8984: | the stack it retrieves this message |
8985: +---------------------------------------------------------*/
8986: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
8987: p_count => x_msg_count,
8988: p_data => x_msg_data
8989: );
8990:

Line 9052: FND_MSG_PUB.initialize;

9048: l_init_msg_list := p_init_msg_list;
9049: END IF;
9050:
9051: IF FND_API.to_Boolean(l_init_msg_list) THEN
9052: FND_MSG_PUB.initialize;
9053: END IF;
9054:
9055: /*-----------------------------------------+
9056: | Initialize return status to SUCCESS |

Line 9229: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

9225: WHEN FND_API.G_EXC_ERROR THEN
9226: ROLLBACK TO Insert_Line_Det_Factors_PVT;
9227: x_return_status := FND_API.G_RET_STS_ERROR ;
9228: /*---------------------------------------------------------+
9229: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
9230: | in the message stack. If there is only one message in |
9231: | the stack it retrieves this message |
9232: +---------------------------------------------------------*/
9233: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 9233: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

9229: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
9230: | in the message stack. If there is only one message in |
9231: | the stack it retrieves this message |
9232: +---------------------------------------------------------*/
9233: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
9234: p_count => x_msg_count,
9235: p_data => x_msg_data
9236: );
9237:

Line 9246: FND_MSG_PUB.Add;

9242: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
9243: ROLLBACK TO Insert_Line_Det_Factors_PVT;
9244: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
9245: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
9246: FND_MSG_PUB.Add;
9247: /*---------------------------------------------------------+
9248: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
9249: | in the message stack. If there is only one message in |
9250: | the stack it retrieves this message |

Line 9248: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

9244: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
9245: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
9246: FND_MSG_PUB.Add;
9247: /*---------------------------------------------------------+
9248: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
9249: | in the message stack. If there is only one message in |
9250: | the stack it retrieves this message |
9251: +---------------------------------------------------------*/
9252: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 9252: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

9248: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
9249: | in the message stack. If there is only one message in |
9250: | the stack it retrieves this message |
9251: +---------------------------------------------------------*/
9252: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
9253: p_count => x_msg_count,
9254: p_data => x_msg_data
9255: );
9256: IF ( G_LEVEL_ERROR >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 9274: FND_MSG_PUB.Add;

9270: ELSE
9271: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
9272: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
9273: END IF;
9274: FND_MSG_PUB.Add;
9275: /*---------------------------------------------------------+
9276: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
9277: | in the message stack. If there is only one message in |
9278: | the stack it retrieves this message |

Line 9276: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

9272: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
9273: END IF;
9274: FND_MSG_PUB.Add;
9275: /*---------------------------------------------------------+
9276: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
9277: | in the message stack. If there is only one message in |
9278: | the stack it retrieves this message |
9279: +---------------------------------------------------------*/
9280: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 9280: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

9276: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
9277: | in the message stack. If there is only one message in |
9278: | the stack it retrieves this message |
9279: +---------------------------------------------------------*/
9280: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
9281: p_count => x_msg_count,
9282: p_data => x_msg_data
9283: );
9284:

Line 9374: FND_MSG_PUB.initialize;

9370: l_init_msg_list := p_init_msg_list;
9371: END IF;
9372:
9373: IF FND_API.to_Boolean(l_init_msg_list) THEN
9374: FND_MSG_PUB.initialize;
9375: END IF;
9376:
9377: /*-----------------------------------------+
9378: | Initialize return status to SUCCESS |

Line 10969: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

10965: WHEN FND_API.G_EXC_ERROR THEN
10966: ROLLBACK TO Update_Det_Factors_Hdr_PVT;
10967: x_return_status := FND_API.G_RET_STS_ERROR ;
10968: /*---------------------------------------------------------+
10969: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
10970: | in the message stack. If there is only one message in |
10971: | the stack it retrieves this message |
10972: +---------------------------------------------------------*/
10973: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 10973: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

10969: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
10970: | in the message stack. If there is only one message in |
10971: | the stack it retrieves this message |
10972: +---------------------------------------------------------*/
10973: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
10974: p_count => x_msg_count,
10975: p_data => x_msg_data
10976: );
10977:

Line 10986: FND_MSG_PUB.Add;

10982: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
10983: ROLLBACK TO Update_Det_Factors_Hdr_PVT;
10984: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
10985: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
10986: FND_MSG_PUB.Add;
10987: /*---------------------------------------------------------+
10988: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
10989: | in the message stack. If there is only one message in |
10990: | the stack it retrieves this message |

Line 10988: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

10984: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
10985: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
10986: FND_MSG_PUB.Add;
10987: /*---------------------------------------------------------+
10988: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
10989: | in the message stack. If there is only one message in |
10990: | the stack it retrieves this message |
10991: +---------------------------------------------------------*/
10992: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 10992: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

10988: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
10989: | in the message stack. If there is only one message in |
10990: | the stack it retrieves this message |
10991: +---------------------------------------------------------*/
10992: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
10993: p_count => x_msg_count,
10994: p_data => x_msg_data
10995: );
10996: IF ( G_LEVEL_ERROR >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 11003: FND_MSG_PUB.Add;

10999: WHEN OTHERS THEN
11000: ROLLBACK TO Update_Det_Factors_Hdr_PVT;
11001: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
11002: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
11003: FND_MSG_PUB.Add;
11004: /*---------------------------------------------------------+
11005: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
11006: | in the message stack. If there is only one message in |
11007: | the stack it retrieves this message |

Line 11005: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

11001: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
11002: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
11003: FND_MSG_PUB.Add;
11004: /*---------------------------------------------------------+
11005: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
11006: | in the message stack. If there is only one message in |
11007: | the stack it retrieves this message |
11008: +---------------------------------------------------------*/
11009: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 11009: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

11005: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
11006: | in the message stack. If there is only one message in |
11007: | the stack it retrieves this message |
11008: +---------------------------------------------------------*/
11009: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
11010: p_count => x_msg_count,
11011: p_data => x_msg_data
11012: );
11013:

Line 11076: FND_MSG_PUB.initialize;

11072: l_init_msg_list := p_init_msg_list;
11073: END IF;
11074:
11075: IF FND_API.to_Boolean(l_init_msg_list) THEN
11076: FND_MSG_PUB.initialize;
11077: END IF;
11078:
11079: /*-----------------------------------------+
11080: | Initialize return status to SUCCESS |

Line 11296: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

11292: WHEN FND_API.G_EXC_ERROR THEN
11293: ROLLBACK TO Update_Line_Det_Factors_PVT;
11294: x_return_status := FND_API.G_RET_STS_ERROR ;
11295: /*---------------------------------------------------------+
11296: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
11297: | in the message stack. If there is only one message in |
11298: | the stack it retrieves this message |
11299: +---------------------------------------------------------*/
11300: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 11300: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

11296: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
11297: | in the message stack. If there is only one message in |
11298: | the stack it retrieves this message |
11299: +---------------------------------------------------------*/
11300: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
11301: p_count => x_msg_count,
11302: p_data => x_msg_data
11303: );
11304:

Line 11313: FND_MSG_PUB.Add;

11309: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
11310: ROLLBACK TO Update_Line_Det_Factors_PVT;
11311: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
11312: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
11313: FND_MSG_PUB.Add;
11314: /*---------------------------------------------------------+
11315: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
11316: | in the message stack. If there is only one message in |
11317: | the stack it retrieves this message |

Line 11315: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

11311: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
11312: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
11313: FND_MSG_PUB.Add;
11314: /*---------------------------------------------------------+
11315: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
11316: | in the message stack. If there is only one message in |
11317: | the stack it retrieves this message |
11318: +---------------------------------------------------------*/
11319: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 11319: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

11315: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
11316: | in the message stack. If there is only one message in |
11317: | the stack it retrieves this message |
11318: +---------------------------------------------------------*/
11319: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
11320: p_count => x_msg_count,
11321: p_data => x_msg_data
11322: );
11323: IF ( G_LEVEL_ERROR >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 11341: FND_MSG_PUB.Add;

11337: ELSE
11338: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
11339: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
11340: END IF;
11341: FND_MSG_PUB.Add;
11342: /*---------------------------------------------------------+
11343: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
11344: | in the message stack. If there is only one message in |
11345: | the stack it retrieves this message |

Line 11343: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

11339: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
11340: END IF;
11341: FND_MSG_PUB.Add;
11342: /*---------------------------------------------------------+
11343: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
11344: | in the message stack. If there is only one message in |
11345: | the stack it retrieves this message |
11346: +---------------------------------------------------------*/
11347: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 11347: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

11343: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
11344: | in the message stack. If there is only one message in |
11345: | the stack it retrieves this message |
11346: +---------------------------------------------------------*/
11347: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
11348: p_count => x_msg_count,
11349: p_data => x_msg_data
11350: );
11351:

Line 11414: FND_MSG_PUB.initialize;

11410: l_init_msg_list := p_init_msg_list;
11411: END IF;
11412:
11413: IF FND_API.to_Boolean(l_init_msg_list) THEN
11414: FND_MSG_PUB.initialize;
11415: END IF;
11416:
11417: /*-----------------------------------------+
11418: | Initialize return status to SUCCESS |

Line 11608: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

11604: WHEN FND_API.G_EXC_ERROR THEN
11605: ROLLBACK TO Copy_Ins_Line_Det_Factors_PVT;
11606: x_return_status := FND_API.G_RET_STS_ERROR ;
11607: /*---------------------------------------------------------+
11608: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
11609: | in the message stack. If there is only one message in |
11610: | the stack it retrieves this message |
11611: +---------------------------------------------------------*/
11612: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 11612: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

11608: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
11609: | in the message stack. If there is only one message in |
11610: | the stack it retrieves this message |
11611: +---------------------------------------------------------*/
11612: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
11613: p_count => x_msg_count,
11614: p_data => x_msg_data
11615: );
11616:

Line 11625: FND_MSG_PUB.Add;

11621: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
11622: ROLLBACK TO Copy_Ins_Line_Det_Factors_PVT;
11623: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
11624: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
11625: FND_MSG_PUB.Add;
11626: /*---------------------------------------------------------+
11627: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
11628: | in the message stack. If there is only one message in |
11629: | the stack it retrieves this message |

Line 11627: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

11623: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
11624: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
11625: FND_MSG_PUB.Add;
11626: /*---------------------------------------------------------+
11627: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
11628: | in the message stack. If there is only one message in |
11629: | the stack it retrieves this message |
11630: +---------------------------------------------------------*/
11631: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 11631: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

11627: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
11628: | in the message stack. If there is only one message in |
11629: | the stack it retrieves this message |
11630: +---------------------------------------------------------*/
11631: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
11632: p_count => x_msg_count,
11633: p_data => x_msg_data
11634: );
11635: IF ( G_LEVEL_ERROR >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 11653: FND_MSG_PUB.Add;

11649: ELSE
11650: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
11651: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
11652: END IF;
11653: FND_MSG_PUB.Add;
11654: /*---------------------------------------------------------+
11655: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
11656: | in the message stack. If there is only one message in |
11657: | the stack it retrieves this message |

Line 11655: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

11651: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
11652: END IF;
11653: FND_MSG_PUB.Add;
11654: /*---------------------------------------------------------+
11655: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
11656: | in the message stack. If there is only one message in |
11657: | the stack it retrieves this message |
11658: +---------------------------------------------------------*/
11659: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 11659: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

11655: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
11656: | in the message stack. If there is only one message in |
11657: | the stack it retrieves this message |
11658: +---------------------------------------------------------*/
11659: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
11660: p_count => x_msg_count,
11661: p_data => x_msg_data
11662: );
11663:

Line 11721: FND_MSG_PUB.initialize;

11717: l_init_msg_list := p_init_msg_list;
11718: END IF;
11719:
11720: IF FND_API.to_Boolean(l_init_msg_list) THEN
11721: FND_MSG_PUB.initialize;
11722: END IF;
11723:
11724: /*-----------------------------------------+
11725: | Initialize return status to SUCCESS |

Line 11767: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

11763: WHEN FND_API.G_EXC_ERROR THEN
11764: ROLLBACK TO Is_Recoverability_Affected_PVT;
11765: x_return_status := FND_API.G_RET_STS_ERROR ;
11766: /*---------------------------------------------------------+
11767: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
11768: | in the message stack. If there is only one message in |
11769: | the stack it retrieves this message |
11770: +---------------------------------------------------------*/
11771: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 11771: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

11767: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
11768: | in the message stack. If there is only one message in |
11769: | the stack it retrieves this message |
11770: +---------------------------------------------------------*/
11771: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
11772: p_count => x_msg_count,
11773: p_data => x_msg_data
11774: );
11775:

Line 11784: FND_MSG_PUB.Add;

11780: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
11781: ROLLBACK TO Is_Recoverability_Affected_PVT;
11782: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
11783: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
11784: FND_MSG_PUB.Add;
11785: /*---------------------------------------------------------+
11786: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
11787: | in the message stack. If there is only one message in |
11788: | the stack it retrieves this message |

Line 11786: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

11782: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
11783: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
11784: FND_MSG_PUB.Add;
11785: /*---------------------------------------------------------+
11786: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
11787: | in the message stack. If there is only one message in |
11788: | the stack it retrieves this message |
11789: +---------------------------------------------------------*/
11790: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 11790: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

11786: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
11787: | in the message stack. If there is only one message in |
11788: | the stack it retrieves this message |
11789: +---------------------------------------------------------*/
11790: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
11791: p_count => x_msg_count,
11792: p_data => x_msg_data
11793: );
11794:

Line 11803: FND_MSG_PUB.Add;

11799: WHEN OTHERS THEN
11800: ROLLBACK TO Is_Recoverability_Affected_PVT;
11801: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
11802: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
11803: FND_MSG_PUB.Add;
11804: /*---------------------------------------------------------+
11805: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
11806: | in the message stack. If there is only one message in |
11807: | the stack it retrieves this message |

Line 11805: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

11801: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
11802: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
11803: FND_MSG_PUB.Add;
11804: /*---------------------------------------------------------+
11805: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
11806: | in the message stack. If there is only one message in |
11807: | the stack it retrieves this message |
11808: +---------------------------------------------------------*/
11809: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 11809: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

11805: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
11806: | in the message stack. If there is only one message in |
11807: | the stack it retrieves this message |
11808: +---------------------------------------------------------*/
11809: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
11810: p_count => x_msg_count,
11811: p_data => x_msg_data
11812: );
11813: IF ( G_LEVEL_UNEXPECTED >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 11869: FND_MSG_PUB.initialize;

11865: l_init_msg_list := p_init_msg_list;
11866: END IF;
11867:
11868: IF FND_API.to_Boolean(l_init_msg_list) THEN
11869: FND_MSG_PUB.initialize;
11870: END IF;
11871:
11872: /*-----------------------------------------+
11873: | Initialize return status to SUCCESS |

Line 11929: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

11925: WHEN FND_API.G_EXC_ERROR THEN
11926: ROLLBACK TO Del_Tax_Line_And_Dists_PVT;
11927: x_return_status := FND_API.G_RET_STS_ERROR ;
11928: /*---------------------------------------------------------+
11929: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
11930: | in the message stack. If there is only one message in |
11931: | the stack it retrieves this message |
11932: +---------------------------------------------------------*/
11933: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 11933: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

11929: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
11930: | in the message stack. If there is only one message in |
11931: | the stack it retrieves this message |
11932: +---------------------------------------------------------*/
11933: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
11934: p_count => x_msg_count,
11935: p_data => x_msg_data
11936: );
11937:

Line 11946: FND_MSG_PUB.Add;

11942: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
11943: ROLLBACK TO Del_Tax_Line_And_Dists_PVT;
11944: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
11945: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
11946: FND_MSG_PUB.Add;
11947: /*---------------------------------------------------------+
11948: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
11949: | in the message stack. If there is only one message in |
11950: | the stack it retrieves this message |

Line 11948: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

11944: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
11945: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
11946: FND_MSG_PUB.Add;
11947: /*---------------------------------------------------------+
11948: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
11949: | in the message stack. If there is only one message in |
11950: | the stack it retrieves this message |
11951: +---------------------------------------------------------*/
11952: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 11952: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

11948: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
11949: | in the message stack. If there is only one message in |
11950: | the stack it retrieves this message |
11951: +---------------------------------------------------------*/
11952: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
11953: p_count => x_msg_count,
11954: p_data => x_msg_data
11955: );
11956:

Line 11965: FND_MSG_PUB.Add;

11961: WHEN OTHERS THEN
11962: ROLLBACK TO Del_Tax_Line_And_Dists_PVT;
11963: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
11964: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
11965: FND_MSG_PUB.Add;
11966: /*---------------------------------------------------------+
11967: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
11968: | in the message stack. If there is only one message in |
11969: | the stack it retrieves this message |

Line 11967: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

11963: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
11964: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
11965: FND_MSG_PUB.Add;
11966: /*---------------------------------------------------------+
11967: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
11968: | in the message stack. If there is only one message in |
11969: | the stack it retrieves this message |
11970: +---------------------------------------------------------*/
11971: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 11971: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

11967: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
11968: | in the message stack. If there is only one message in |
11969: | the stack it retrieves this message |
11970: +---------------------------------------------------------*/
11971: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
11972: p_count => x_msg_count,
11973: p_data => x_msg_data
11974: );
11975: IF ( G_LEVEL_UNEXPECTED >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 12031: FND_MSG_PUB.initialize;

12027: l_init_msg_list := p_init_msg_list;
12028: END IF;
12029:
12030: IF FND_API.to_Boolean(l_init_msg_list) THEN
12031: FND_MSG_PUB.initialize;
12032: END IF;
12033:
12034: /*-----------------------------------------+
12035: | Initialize return status to SUCCESS |

Line 12084: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

12080: WHEN FND_API.G_EXC_ERROR THEN
12081: ROLLBACK TO Del_Tax_Distributions_PVT;
12082: x_return_status := FND_API.G_RET_STS_ERROR ;
12083: /*---------------------------------------------------------+
12084: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
12085: | in the message stack. If there is only one message in |
12086: | the stack it retrieves this message |
12087: +---------------------------------------------------------*/
12088: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 12088: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

12084: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
12085: | in the message stack. If there is only one message in |
12086: | the stack it retrieves this message |
12087: +---------------------------------------------------------*/
12088: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
12089: p_count => x_msg_count,
12090: p_data => x_msg_data
12091: );
12092:

Line 12101: FND_MSG_PUB.Add;

12097: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
12098: ROLLBACK TO Del_Tax_Distributions_PVT;
12099: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
12100: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
12101: FND_MSG_PUB.Add;
12102: /*---------------------------------------------------------+
12103: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
12104: | in the message stack. If there is only one message in |
12105: | the stack it retrieves this message |

Line 12103: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

12099: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
12100: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
12101: FND_MSG_PUB.Add;
12102: /*---------------------------------------------------------+
12103: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
12104: | in the message stack. If there is only one message in |
12105: | the stack it retrieves this message |
12106: +---------------------------------------------------------*/
12107: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 12107: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

12103: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
12104: | in the message stack. If there is only one message in |
12105: | the stack it retrieves this message |
12106: +---------------------------------------------------------*/
12107: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
12108: p_count => x_msg_count,
12109: p_data => x_msg_data
12110: );
12111:

Line 12120: FND_MSG_PUB.Add;

12116: WHEN OTHERS THEN
12117: ROLLBACK TO Del_Tax_Distributions_PVT;
12118: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
12119: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
12120: FND_MSG_PUB.Add;
12121: /*---------------------------------------------------------+
12122: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
12123: | in the message stack. If there is only one message in |
12124: | the stack it retrieves this message |

Line 12122: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

12118: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
12119: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
12120: FND_MSG_PUB.Add;
12121: /*---------------------------------------------------------+
12122: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
12123: | in the message stack. If there is only one message in |
12124: | the stack it retrieves this message |
12125: +---------------------------------------------------------*/
12126: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 12126: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

12122: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
12123: | in the message stack. If there is only one message in |
12124: | the stack it retrieves this message |
12125: +---------------------------------------------------------*/
12126: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
12127: p_count => x_msg_count,
12128: p_data => x_msg_data
12129: );
12130: IF ( G_LEVEL_UNEXPECTED >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 12254: FND_MSG_PUB.initialize;

12250: l_init_msg_list := p_init_msg_list;
12251: END IF;
12252:
12253: IF FND_API.to_Boolean(l_init_msg_list) THEN
12254: FND_MSG_PUB.initialize;
12255: END IF;
12256:
12257: /*-----------------------------------------+
12258: | Initialize return status to SUCCESS |

Line 12432: FND_MSG_PUB.Add;

12428: --Close all open cursors
12429: IF headers_doc%ISOPEN THEN CLOSE headers_doc; END IF;
12430: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
12431: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
12432: FND_MSG_PUB.Add;
12433: /*---------------------------------------------------------+
12434: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
12435: | in the message stack. If there is only one message in |
12436: | the stack it retrieves this message |

Line 12434: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

12430: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
12431: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
12432: FND_MSG_PUB.Add;
12433: /*---------------------------------------------------------+
12434: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
12435: | in the message stack. If there is only one message in |
12436: | the stack it retrieves this message |
12437: +---------------------------------------------------------*/
12438: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 12438: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

12434: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
12435: | in the message stack. If there is only one message in |
12436: | the stack it retrieves this message |
12437: +---------------------------------------------------------*/
12438: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
12439: p_count => x_msg_count,
12440: p_data => x_msg_data
12441: );
12442: IF ( G_LEVEL_ERROR >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 12452: FND_MSG_PUB.Add;

12448: --Close all open cursors
12449: IF headers_doc%ISOPEN THEN CLOSE headers_doc; END IF;
12450: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
12451: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
12452: FND_MSG_PUB.Add;
12453: /*---------------------------------------------------------+
12454: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
12455: | in the message stack. If there is only one message in |
12456: | the stack it retrieves this message |

Line 12454: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

12450: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
12451: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
12452: FND_MSG_PUB.Add;
12453: /*---------------------------------------------------------+
12454: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
12455: | in the message stack. If there is only one message in |
12456: | the stack it retrieves this message |
12457: +---------------------------------------------------------*/
12458: IF ( G_LEVEL_UNEXPECTED >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 12520: FND_MSG_PUB.initialize;

12516: l_init_msg_list := p_init_msg_list;
12517: END IF;
12518:
12519: IF FND_API.to_Boolean(l_init_msg_list) THEN
12520: FND_MSG_PUB.initialize;
12521: END IF;
12522:
12523: /*-----------------------------------------+
12524: | Initialize return status to SUCCESS |

Line 12583: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

12579: WHEN FND_API.G_EXC_ERROR THEN
12580: ROLLBACK TO Redefault_Intended_Use_PVT;
12581: x_return_status := FND_API.G_RET_STS_ERROR ;
12582: /*---------------------------------------------------------+
12583: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
12584: | in the message stack. If there is only one message in |
12585: | the stack it retrieves this message |
12586: +---------------------------------------------------------*/
12587: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 12587: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

12583: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
12584: | in the message stack. If there is only one message in |
12585: | the stack it retrieves this message |
12586: +---------------------------------------------------------*/
12587: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
12588: p_count => x_msg_count,
12589: p_data => x_msg_data
12590: );
12591: IF ( G_LEVEL_ERROR >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 12599: FND_MSG_PUB.Add;

12595: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
12596: ROLLBACK TO Redefault_Intended_Use_PVT;
12597: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
12598: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
12599: FND_MSG_PUB.Add;
12600: /*---------------------------------------------------------+
12601: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
12602: | in the message stack. If there is only one message in |
12603: | the stack it retrieves this message |

Line 12601: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

12597: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
12598: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
12599: FND_MSG_PUB.Add;
12600: /*---------------------------------------------------------+
12601: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
12602: | in the message stack. If there is only one message in |
12603: | the stack it retrieves this message |
12604: +---------------------------------------------------------*/
12605: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 12605: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

12601: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
12602: | in the message stack. If there is only one message in |
12603: | the stack it retrieves this message |
12604: +---------------------------------------------------------*/
12605: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
12606: p_count => x_msg_count,
12607: p_data => x_msg_data
12608: );
12609: IF ( G_LEVEL_ERROR >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 12617: FND_MSG_PUB.Add;

12613: WHEN OTHERS THEN
12614: ROLLBACK TO Redefault_Intended_Use_PVT;
12615: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
12616: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
12617: FND_MSG_PUB.Add;
12618: /*---------------------------------------------------------+
12619: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
12620: | in the message stack. If there is only one message in |
12621: | the stack it retrieves this message |

Line 12619: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

12615: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
12616: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
12617: FND_MSG_PUB.Add;
12618: /*---------------------------------------------------------+
12619: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
12620: | in the message stack. If there is only one message in |
12621: | the stack it retrieves this message |
12622: +---------------------------------------------------------*/
12623: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 12623: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

12619: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
12620: | in the message stack. If there is only one message in |
12621: | the stack it retrieves this message |
12622: +---------------------------------------------------------*/
12623: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
12624: p_count => x_msg_count,
12625: p_data => x_msg_data
12626: );
12627: IF ( G_LEVEL_UNEXPECTED >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 12689: FND_MSG_PUB.initialize;

12685: l_init_msg_list := p_init_msg_list;
12686: END IF;
12687:
12688: IF FND_API.to_Boolean(l_init_msg_list) THEN
12689: FND_MSG_PUB.initialize;
12690: END IF;
12691:
12692: /*-----------------------------------------+
12693: | Initialize return status to SUCCESS |

Line 12751: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

12747: WHEN FND_API.G_EXC_ERROR THEN
12748: ROLLBACK TO Redef_Prod_Fisc_Class_Code_PVT;
12749: x_return_status := FND_API.G_RET_STS_ERROR ;
12750: /*---------------------------------------------------------+
12751: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
12752: | in the message stack. If there is only one message in |
12753: | the stack it retrieves this message |
12754: +---------------------------------------------------------*/
12755: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 12755: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

12751: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
12752: | in the message stack. If there is only one message in |
12753: | the stack it retrieves this message |
12754: +---------------------------------------------------------*/
12755: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
12756: p_count => x_msg_count,
12757: p_data => x_msg_data
12758: );
12759:

Line 12768: FND_MSG_PUB.Add;

12764: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
12765: ROLLBACK TO Redef_Prod_Fisc_Class_Code_PVT;
12766: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
12767: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
12768: FND_MSG_PUB.Add;
12769: /*---------------------------------------------------------+
12770: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
12771: | in the message stack. If there is only one message in |
12772: | the stack it retrieves this message |

Line 12770: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

12766: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
12767: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
12768: FND_MSG_PUB.Add;
12769: /*---------------------------------------------------------+
12770: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
12771: | in the message stack. If there is only one message in |
12772: | the stack it retrieves this message |
12773: +---------------------------------------------------------*/
12774: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 12774: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

12770: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
12771: | in the message stack. If there is only one message in |
12772: | the stack it retrieves this message |
12773: +---------------------------------------------------------*/
12774: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
12775: p_count => x_msg_count,
12776: p_data => x_msg_data
12777: );
12778: IF ( G_LEVEL_ERROR >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 12786: FND_MSG_PUB.Add;

12782: WHEN OTHERS THEN
12783: ROLLBACK TO Redef_Prod_Fisc_Class_Code_PVT;
12784: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
12785: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
12786: FND_MSG_PUB.Add;
12787: /*---------------------------------------------------------+
12788: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
12789: | in the message stack. If there is only one message in |
12790: | the stack it retrieves this message |

Line 12788: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

12784: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
12785: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
12786: FND_MSG_PUB.Add;
12787: /*---------------------------------------------------------+
12788: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
12789: | in the message stack. If there is only one message in |
12790: | the stack it retrieves this message |
12791: +---------------------------------------------------------*/
12792: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 12792: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

12788: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
12789: | in the message stack. If there is only one message in |
12790: | the stack it retrieves this message |
12791: +---------------------------------------------------------*/
12792: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
12793: p_count => x_msg_count,
12794: p_data => x_msg_data
12795: );
12796: IF ( G_LEVEL_UNEXPECTED >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 12862: FND_MSG_PUB.initialize;

12858: l_init_msg_list := p_init_msg_list;
12859: END IF;
12860:
12861: IF FND_API.to_Boolean(l_init_msg_list) THEN
12862: FND_MSG_PUB.initialize;
12863: END IF;
12864:
12865: /*-----------------------------------------+
12866: | Initialize return status to SUCCESS |

Line 12931: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

12927: WHEN FND_API.G_EXC_ERROR THEN
12928: ROLLBACK TO Redefault_Assessable_Value_PVT;
12929: x_return_status := FND_API.G_RET_STS_ERROR ;
12930: /*---------------------------------------------------------+
12931: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
12932: | in the message stack. If there is only one message in |
12933: | the stack it retrieves this message |
12934: +---------------------------------------------------------*/
12935: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 12935: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

12931: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
12932: | in the message stack. If there is only one message in |
12933: | the stack it retrieves this message |
12934: +---------------------------------------------------------*/
12935: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
12936: p_count => x_msg_count,
12937: p_data => x_msg_data
12938: );
12939: IF ( G_LEVEL_ERROR >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 12947: FND_MSG_PUB.Add;

12943: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
12944: ROLLBACK TO Redefault_Assessable_Value_PVT;
12945: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
12946: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
12947: FND_MSG_PUB.Add;
12948: /*---------------------------------------------------------+
12949: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
12950: | in the message stack. If there is only one message in |
12951: | the stack it retrieves this message |

Line 12949: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

12945: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
12946: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
12947: FND_MSG_PUB.Add;
12948: /*---------------------------------------------------------+
12949: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
12950: | in the message stack. If there is only one message in |
12951: | the stack it retrieves this message |
12952: +---------------------------------------------------------*/
12953: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 12953: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

12949: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
12950: | in the message stack. If there is only one message in |
12951: | the stack it retrieves this message |
12952: +---------------------------------------------------------*/
12953: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
12954: p_count => x_msg_count,
12955: p_data => x_msg_data
12956: );
12957: IF ( G_LEVEL_ERROR >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 12965: FND_MSG_PUB.Add;

12961: WHEN OTHERS THEN
12962: ROLLBACK TO Redefault_Assessable_Value_PVT;
12963: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
12964: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
12965: FND_MSG_PUB.Add;
12966: /*---------------------------------------------------------+
12967: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
12968: | in the message stack. If there is only one message in |
12969: | the stack it retrieves this message |

Line 12967: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

12963: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
12964: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
12965: FND_MSG_PUB.Add;
12966: /*---------------------------------------------------------+
12967: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
12968: | in the message stack. If there is only one message in |
12969: | the stack it retrieves this message |
12970: +---------------------------------------------------------*/
12971: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 12971: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

12967: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
12968: | in the message stack. If there is only one message in |
12969: | the stack it retrieves this message |
12970: +---------------------------------------------------------*/
12971: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
12972: p_count => x_msg_count,
12973: p_data => x_msg_data
12974: );
12975: IF ( G_LEVEL_UNEXPECTED >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 13036: FND_MSG_PUB.initialize;

13032: l_init_msg_list := p_init_msg_list;
13033: END IF;
13034:
13035: IF FND_API.to_Boolean(l_init_msg_list) THEN
13036: FND_MSG_PUB.initialize;
13037: END IF;
13038:
13039: /*-----------------------------------------+
13040: | Initialize return status to SUCCESS |

Line 13100: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

13096: WHEN FND_API.G_EXC_ERROR THEN
13097: ROLLBACK TO Redefault_Assessable_Value_PVT;
13098: x_return_status := FND_API.G_RET_STS_ERROR ;
13099: /*---------------------------------------------------------+
13100: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
13101: | in the message stack. If there is only one message in |
13102: | the stack it retrieves this message |
13103: +---------------------------------------------------------*/
13104: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 13104: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

13100: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
13101: | in the message stack. If there is only one message in |
13102: | the stack it retrieves this message |
13103: +---------------------------------------------------------*/
13104: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
13105: p_count => x_msg_count,
13106: p_data => x_msg_data
13107: );
13108: IF ( G_LEVEL_ERROR >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 13116: FND_MSG_PUB.Add;

13112: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
13113: ROLLBACK TO Redefault_Assessable_Value_PVT;
13114: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
13115: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
13116: FND_MSG_PUB.Add;
13117: /*---------------------------------------------------------+
13118: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
13119: | in the message stack. If there is only one message in |
13120: | the stack it retrieves this message |

Line 13118: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

13114: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
13115: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
13116: FND_MSG_PUB.Add;
13117: /*---------------------------------------------------------+
13118: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
13119: | in the message stack. If there is only one message in |
13120: | the stack it retrieves this message |
13121: +---------------------------------------------------------*/
13122: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 13122: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

13118: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
13119: | in the message stack. If there is only one message in |
13120: | the stack it retrieves this message |
13121: +---------------------------------------------------------*/
13122: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
13123: p_count => x_msg_count,
13124: p_data => x_msg_data
13125: );
13126: IF ( G_LEVEL_ERROR >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 13134: FND_MSG_PUB.Add;

13130: WHEN OTHERS THEN
13131: ROLLBACK TO Redefault_Assessable_Value_PVT;
13132: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
13133: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
13134: FND_MSG_PUB.Add;
13135: /*---------------------------------------------------------+
13136: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
13137: | in the message stack. If there is only one message in |
13138: | the stack it retrieves this message |

Line 13136: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

13132: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
13133: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
13134: FND_MSG_PUB.Add;
13135: /*---------------------------------------------------------+
13136: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
13137: | in the message stack. If there is only one message in |
13138: | the stack it retrieves this message |
13139: +---------------------------------------------------------*/
13140: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 13140: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

13136: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
13137: | in the message stack. If there is only one message in |
13138: | the stack it retrieves this message |
13139: +---------------------------------------------------------*/
13140: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
13141: p_count => x_msg_count,
13142: p_data => x_msg_data
13143: );
13144: IF ( G_LEVEL_UNEXPECTED >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 13198: FND_MSG_PUB.initialize;

13194: l_init_msg_list := p_init_msg_list;
13195: END IF;
13196:
13197: IF FND_API.to_Boolean(l_init_msg_list) THEN
13198: FND_MSG_PUB.initialize;
13199: END IF;
13200:
13201: /*-----------------------------------------+
13202: | Initialize return status to SUCCESS |

Line 13293: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

13289: WHEN FND_API.G_EXC_ERROR THEN
13290: ROLLBACK TO Redef_Tax_Class_Code_PVT;
13291: x_return_status := FND_API.G_RET_STS_ERROR ;
13292: /*---------------------------------------------------------+
13293: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
13294: | in the message stack. If there is only one message in |
13295: | the stack it retrieves this message |
13296: +---------------------------------------------------------*/
13297: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 13297: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

13293: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
13294: | in the message stack. If there is only one message in |
13295: | the stack it retrieves this message |
13296: +---------------------------------------------------------*/
13297: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
13298: p_count => x_msg_count,
13299: p_data => x_msg_data
13300: );
13301: IF ( G_LEVEL_ERROR >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 13309: FND_MSG_PUB.Add;

13305: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
13306: ROLLBACK TO Redef_Tax_Class_Code_PVT;
13307: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
13308: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
13309: FND_MSG_PUB.Add;
13310: /*---------------------------------------------------------+
13311: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
13312: | in the message stack. If there is only one message in |
13313: | the stack it retrieves this message |

Line 13311: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

13307: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
13308: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
13309: FND_MSG_PUB.Add;
13310: /*---------------------------------------------------------+
13311: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
13312: | in the message stack. If there is only one message in |
13313: | the stack it retrieves this message |
13314: +---------------------------------------------------------*/
13315: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 13315: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

13311: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
13312: | in the message stack. If there is only one message in |
13313: | the stack it retrieves this message |
13314: +---------------------------------------------------------*/
13315: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
13316: p_count => x_msg_count,
13317: p_data => x_msg_data
13318: );
13319: IF ( G_LEVEL_ERROR >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 13327: FND_MSG_PUB.Add;

13323: WHEN OTHERS THEN
13324: ROLLBACK TO Redef_Tax_Class_Code_PVT;
13325: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
13326: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
13327: FND_MSG_PUB.Add;
13328: /*---------------------------------------------------------+
13329: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
13330: | in the message stack. If there is only one message in |
13331: | the stack it retrieves this message |

Line 13329: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

13325: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
13326: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
13327: FND_MSG_PUB.Add;
13328: /*---------------------------------------------------------+
13329: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
13330: | in the message stack. If there is only one message in |
13331: | the stack it retrieves this message |
13332: +---------------------------------------------------------*/
13333: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 13333: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

13329: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
13330: | in the message stack. If there is only one message in |
13331: | the stack it retrieves this message |
13332: +---------------------------------------------------------*/
13333: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
13334: p_count => x_msg_count,
13335: p_data => x_msg_data
13336: );
13337: IF ( G_LEVEL_UNEXPECTED >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 13398: FND_MSG_PUB.initialize;

13394: l_init_msg_list := p_init_msg_list;
13395: END IF;
13396:
13397: IF FND_API.to_Boolean(l_init_msg_list) THEN
13398: FND_MSG_PUB.initialize;
13399: END IF;
13400:
13401: /*-----------------------------------------+
13402: | Initialize return status to SUCCESS |

Line 13557: FND_MSG_PUB.Add;

13553: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
13554: ROLLBACK TO Purge_Tax_Repository_PVT;
13555: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
13556: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
13557: FND_MSG_PUB.Add;
13558: /*---------------------------------------------------------+
13559: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
13560: | in the message stack. If there is only one message in |
13561: | the stack it retrieves this message |

Line 13559: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

13555: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
13556: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
13557: FND_MSG_PUB.Add;
13558: /*---------------------------------------------------------+
13559: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
13560: | in the message stack. If there is only one message in |
13561: | the stack it retrieves this message |
13562: +---------------------------------------------------------*/
13563: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 13563: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

13559: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
13560: | in the message stack. If there is only one message in |
13561: | the stack it retrieves this message |
13562: +---------------------------------------------------------*/
13563: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
13564: p_count => x_msg_count,
13565: p_data => x_msg_data
13566: );
13567: IF ( G_LEVEL_ERROR >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 13575: FND_MSG_PUB.Add;

13571: WHEN OTHERS THEN
13572: ROLLBACK TO Purge_Tax_Repository_PVT;
13573: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
13574: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
13575: FND_MSG_PUB.Add;
13576: /*---------------------------------------------------------+
13577: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
13578: | in the message stack. If there is only one message in |
13579: | the stack it retrieves this message |

Line 13577: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

13573: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
13574: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
13575: FND_MSG_PUB.Add;
13576: /*---------------------------------------------------------+
13577: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
13578: | in the message stack. If there is only one message in |
13579: | the stack it retrieves this message |
13580: +---------------------------------------------------------*/
13581: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 13581: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

13577: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
13578: | in the message stack. If there is only one message in |
13579: | the stack it retrieves this message |
13580: +---------------------------------------------------------*/
13581: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
13582: p_count => x_msg_count,
13583: p_data => x_msg_data
13584: );
13585: IF ( G_LEVEL_UNEXPECTED >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 13643: FND_MSG_PUB.initialize;

13639: l_init_msg_list := p_init_msg_list;
13640: END IF;
13641:
13642: IF FND_API.to_Boolean(l_init_msg_list) THEN
13643: FND_MSG_PUB.initialize;
13644: END IF;
13645:
13646: /*-----------------------------------------+
13647: | Initialize return status to SUCCESS |

Line 13703: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

13699: WHEN FND_API.G_EXC_ERROR THEN
13700: ROLLBACK TO GET_LE_FROM_TAX_REGISTRATN_PVT;
13701: x_return_status := FND_API.G_RET_STS_ERROR ;
13702: /*---------------------------------------------------------+
13703: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
13704: | in the message stack. If there is only one message in |
13705: | the stack it retrieves this message |
13706: +---------------------------------------------------------*/
13707: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 13707: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

13703: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
13704: | in the message stack. If there is only one message in |
13705: | the stack it retrieves this message |
13706: +---------------------------------------------------------*/
13707: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
13708: p_count => x_msg_count,
13709: p_data => x_msg_data
13710: );
13711: IF ( G_LEVEL_ERROR >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 13719: FND_MSG_PUB.Add;

13715: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
13716: ROLLBACK TO GET_LE_FROM_TAX_REGISTRATN_PVT;
13717: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
13718: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
13719: FND_MSG_PUB.Add;
13720: /*---------------------------------------------------------+
13721: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
13722: | in the message stack. If there is only one message in |
13723: | the stack it retrieves this message |

Line 13721: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

13717: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
13718: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
13719: FND_MSG_PUB.Add;
13720: /*---------------------------------------------------------+
13721: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
13722: | in the message stack. If there is only one message in |
13723: | the stack it retrieves this message |
13724: +---------------------------------------------------------*/
13725: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 13725: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

13721: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
13722: | in the message stack. If there is only one message in |
13723: | the stack it retrieves this message |
13724: +---------------------------------------------------------*/
13725: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
13726: p_count => x_msg_count,
13727: p_data => x_msg_data
13728: );
13729: IF ( G_LEVEL_ERROR >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 13737: FND_MSG_PUB.Add;

13733: WHEN OTHERS THEN
13734: ROLLBACK TO GET_LE_FROM_TAX_REGISTRATN_PVT;
13735: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
13736: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
13737: FND_MSG_PUB.Add;
13738: /*---------------------------------------------------------+
13739: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
13740: | in the message stack. If there is only one message in |
13741: | the stack it retrieves this message |

Line 13739: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

13735: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
13736: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
13737: FND_MSG_PUB.Add;
13738: /*---------------------------------------------------------+
13739: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
13740: | in the message stack. If there is only one message in |
13741: | the stack it retrieves this message |
13742: +---------------------------------------------------------*/
13743: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 13743: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

13739: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
13740: | in the message stack. If there is only one message in |
13741: | the stack it retrieves this message |
13742: +---------------------------------------------------------*/
13743: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
13744: p_count => x_msg_count,
13745: p_data => x_msg_data
13746: );
13747: IF ( G_LEVEL_UNEXPECTED >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 13802: FND_MSG_PUB.initialize;

13798: l_init_msg_list := p_init_msg_list;
13799: END IF;
13800:
13801: IF FND_API.to_Boolean(l_init_msg_list) THEN
13802: FND_MSG_PUB.initialize;
13803: END IF;
13804:
13805: /*-----------------------------------------+
13806: | Initialize return status to SUCCESS |

Line 13848: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

13844: WHEN FND_API.G_EXC_ERROR THEN
13845: ROLLBACK TO update_posting_flag_PVT;
13846: x_return_status := FND_API.G_RET_STS_ERROR ;
13847: /*---------------------------------------------------------+
13848: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
13849: | in the message stack. If there is only one message in |
13850: | the stack it retrieves this message |
13851: +---------------------------------------------------------*/
13852: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 13852: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

13848: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
13849: | in the message stack. If there is only one message in |
13850: | the stack it retrieves this message |
13851: +---------------------------------------------------------*/
13852: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
13853: p_count => x_msg_count,
13854: p_data => x_msg_data
13855: );
13856:

Line 13865: FND_MSG_PUB.Add;

13861: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
13862: ROLLBACK TO update_posting_flag_PVT;
13863: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
13864: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
13865: FND_MSG_PUB.Add;
13866: /*---------------------------------------------------------+
13867: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
13868: | in the message stack. If there is only one message in |
13869: | the stack it retrieves this message |

Line 13867: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

13863: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
13864: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
13865: FND_MSG_PUB.Add;
13866: /*---------------------------------------------------------+
13867: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
13868: | in the message stack. If there is only one message in |
13869: | the stack it retrieves this message |
13870: +---------------------------------------------------------*/
13871: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 13871: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

13867: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
13868: | in the message stack. If there is only one message in |
13869: | the stack it retrieves this message |
13870: +---------------------------------------------------------*/
13871: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
13872: p_count => x_msg_count,
13873: p_data => x_msg_data
13874: );
13875:

Line 13884: FND_MSG_PUB.Add;

13880: WHEN OTHERS THEN
13881: ROLLBACK TO update_posting_flag_PVT;
13882: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
13883: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
13884: FND_MSG_PUB.Add;
13885: /*---------------------------------------------------------+
13886: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
13887: | in the message stack. If there is only one message in |
13888: | the stack it retrieves this message |

Line 13886: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|

13882: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
13883: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
13884: FND_MSG_PUB.Add;
13885: /*---------------------------------------------------------+
13886: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
13887: | in the message stack. If there is only one message in |
13888: | the stack it retrieves this message |
13889: +---------------------------------------------------------*/
13890: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

Line 13890: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

13886: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
13887: | in the message stack. If there is only one message in |
13888: | the stack it retrieves this message |
13889: +---------------------------------------------------------*/
13890: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
13891: p_count => x_msg_count,
13892: p_data => x_msg_data
13893: );
13894: IF ( G_LEVEL_UNEXPECTED >= G_CURRENT_RUNTIME_LEVEL) THEN