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 843: FND_MSG_PUB.initialize;

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

Line 1229: FND_MSG_PUB.Add;

1225: END IF;
1226:
1227: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
1228: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
1229: FND_MSG_PUB.Add;
1230:
1231: IF c_HEADERS%ISOPEN THEN
1232: close c_HEADERS;
1233: END IF;

Line 1290: FND_MSG_PUB.Add;

1286: END IF;
1287:
1288: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
1289: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
1290: FND_MSG_PUB.Add;
1291:
1292: IF c_HEADERS%ISOPEN THEN
1293: close c_HEADERS;
1294: END IF;

Line 1451: FND_MSG_PUB.add;

1447: IF common_header_info%ISOPEN THEN CLOSE common_header_info; END IF;
1448: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
1449: DUMP_MSG;
1450: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
1451: FND_MSG_PUB.add;
1452: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
1453: p_count => x_msg_count,
1454: p_data => x_msg_data
1455: );

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

1448: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
1449: DUMP_MSG;
1450: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
1451: FND_MSG_PUB.add;
1452: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
1453: p_count => x_msg_count,
1454: p_data => x_msg_data
1455: );
1456: IF ( G_LEVEL_ERROR >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 1498: FND_MSG_PUB.add;

1494: IF common_header_info%ISOPEN THEN CLOSE common_header_info; END IF;
1495: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
1496: DUMP_MSG;
1497: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
1498: FND_MSG_PUB.add;
1499: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
1500: p_count => x_msg_count,
1501: p_data => x_msg_data
1502: );

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

1495: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
1496: DUMP_MSG;
1497: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
1498: FND_MSG_PUB.add;
1499: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
1500: p_count => x_msg_count,
1501: p_data => x_msg_data
1502: );
1503: l_end_time:=SYSDATE;

Line 1605: FND_MSG_PUB.initialize;

1601: l_init_msg_list := p_init_msg_list;
1602: END IF;
1603:
1604: IF FND_API.to_Boolean(l_init_msg_list) THEN
1605: FND_MSG_PUB.initialize;
1606: END IF;
1607:
1608: /*-----------------------------------------+
1609: | Initialize return status to SUCCESS |

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

2251: ROLLBACK TO Calculate_tax_PVT;
2252: x_return_status := FND_API.G_RET_STS_ERROR ;
2253: DUMP_MSG;
2254: /*---------------------------------------------------------+
2255: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
2256: | in the message stack. If there is only one message in |
2257: | the stack it retrieves this message |
2258: +---------------------------------------------------------*/
2259: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

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

2255: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
2256: | in the message stack. If there is only one message in |
2257: | the stack it retrieves this message |
2258: +---------------------------------------------------------*/
2259: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
2260: p_count => x_msg_count,
2261: p_data => x_msg_data
2262: );
2263:

Line 2297: FND_MSG_PUB.Add;

2293: ROLLBACK TO Calculate_tax_PVT;
2294: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
2295: DUMP_MSG;
2296: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
2297: FND_MSG_PUB.Add;
2298: /*---------------------------------------------------------+
2299: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
2300: | in the message stack. If there is only one message in |
2301: | the stack it retrieves this message |

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

2295: DUMP_MSG;
2296: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
2297: FND_MSG_PUB.Add;
2298: /*---------------------------------------------------------+
2299: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
2300: | in the message stack. If there is only one message in |
2301: | the stack it retrieves this message |
2302: +---------------------------------------------------------*/
2303: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

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

2299: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
2300: | in the message stack. If there is only one message in |
2301: | the stack it retrieves this message |
2302: +---------------------------------------------------------*/
2303: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
2304: p_count => x_msg_count,
2305: p_data => x_msg_data
2306: );
2307: IF ( G_LEVEL_ERROR >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 2339: FND_MSG_PUB.Add;

2335: WHEN OTHERS THEN
2336: ROLLBACK TO Calculate_tax_PVT;
2337: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
2338: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
2339: FND_MSG_PUB.Add;
2340: /*---------------------------------------------------------+
2341: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
2342: | in the message stack. If there is only one message in |
2343: | the stack it retrieves this message |

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

2337: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
2338: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
2339: FND_MSG_PUB.Add;
2340: /*---------------------------------------------------------+
2341: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
2342: | in the message stack. If there is only one message in |
2343: | the stack it retrieves this message |
2344: +---------------------------------------------------------*/
2345: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

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

2341: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
2342: | in the message stack. If there is only one message in |
2343: | the stack it retrieves this message |
2344: +---------------------------------------------------------*/
2345: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
2346: p_count => x_msg_count,
2347: p_data => x_msg_data
2348: );
2349:

Line 2471: FND_MSG_PUB.initialize;

2467: l_init_msg_list := p_init_msg_list;
2468: END IF;
2469:
2470: IF FND_API.to_Boolean(l_init_msg_list) THEN
2471: FND_MSG_PUB.initialize;
2472: END IF;
2473:
2474:
2475: /*-----------------------------------------+

Line 2859: FND_MSG_PUB.Add;

2855: --Close all open cursors
2856: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
2857: DUMP_MSG;
2858: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
2859: FND_MSG_PUB.Add;
2860: /*---------------------------------------------------------+
2861: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
2862: | in the message stack. If there is only one message in |
2863: | the stack it retrieves this message |

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

2857: DUMP_MSG;
2858: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
2859: FND_MSG_PUB.Add;
2860: /*---------------------------------------------------------+
2861: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
2862: | in the message stack. If there is only one message in |
2863: | the stack it retrieves this message |
2864: +---------------------------------------------------------*/
2865: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

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

2861: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
2862: | in the message stack. If there is only one message in |
2863: | the stack it retrieves this message |
2864: +---------------------------------------------------------*/
2865: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
2866: p_count => x_msg_count,
2867: p_data => x_msg_data
2868: );
2869: IF ( G_LEVEL_ERROR >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 2921: FND_MSG_PUB.Add;

2917: ROLLBACK TO Import_Document_PVT;
2918: --Close all open cursors
2919: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
2920: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
2921: FND_MSG_PUB.Add;
2922: /*---------------------------------------------------------+
2923: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
2924: | in the message stack. If there is only one message in |
2925: | the stack it retrieves this message |

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

2919: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
2920: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
2921: FND_MSG_PUB.Add;
2922: /*---------------------------------------------------------+
2923: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
2924: | in the message stack. If there is only one message in |
2925: | the stack it retrieves this message |
2926: +---------------------------------------------------------*/
2927: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

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

2923: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
2924: | in the message stack. If there is only one message in |
2925: | the stack it retrieves this message |
2926: +---------------------------------------------------------*/
2927: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
2928: p_count => x_msg_count,
2929: p_data => x_msg_data
2930: );
2931:

Line 3039: FND_MSG_PUB.initialize;

3035: l_init_msg_list := p_init_msg_list;
3036: END IF;
3037:
3038: IF FND_API.to_Boolean(l_init_msg_list) THEN
3039: FND_MSG_PUB.initialize;
3040: END IF;
3041:
3042: /*-----------------------------------------+
3043: | Initialize return status to SUCCESS |

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

3355: ROLLBACK TO Synchronize_tax_PVT;
3356: x_return_status := FND_API.G_RET_STS_ERROR ;
3357: DUMP_MSG;
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: IF ( G_LEVEL_ERROR >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 3384: FND_MSG_PUB.Add;

3380: ROLLBACK TO Synchronize_tax_PVT;
3381: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
3382: DUMP_MSG;
3383: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
3384: FND_MSG_PUB.Add;
3385: /*---------------------------------------------------------+
3386: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
3387: | in the message stack. If there is only one message in |
3388: | the stack it retrieves this message |

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

3382: DUMP_MSG;
3383: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
3384: FND_MSG_PUB.Add;
3385: /*---------------------------------------------------------+
3386: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
3387: | in the message stack. If there is only one message in |
3388: | the stack it retrieves this message |
3389: +---------------------------------------------------------*/
3390: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

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

3386: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
3387: | in the message stack. If there is only one message in |
3388: | the stack it retrieves this message |
3389: +---------------------------------------------------------*/
3390: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
3391: p_count => x_msg_count,
3392: p_data => x_msg_data
3393: );
3394: IF ( G_LEVEL_ERROR >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 3411: FND_MSG_PUB.Add;

3407: WHEN OTHERS THEN
3408: ROLLBACK TO Synchronize_tax_PVT;
3409: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
3410: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
3411: FND_MSG_PUB.Add;
3412: /*---------------------------------------------------------+
3413: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
3414: | in the message stack. If there is only one message in |
3415: | the stack it retrieves this message |

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

3409: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
3410: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
3411: FND_MSG_PUB.Add;
3412: /*---------------------------------------------------------+
3413: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
3414: | in the message stack. If there is only one message in |
3415: | the stack it retrieves this message |
3416: +---------------------------------------------------------*/
3417: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

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

3413: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
3414: | in the message stack. If there is only one message in |
3415: | the stack it retrieves this message |
3416: +---------------------------------------------------------*/
3417: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
3418: p_count => x_msg_count,
3419: p_data => x_msg_data
3420: );
3421: IF ( G_LEVEL_UNEXPECTED >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 3519: FND_MSG_PUB.initialize;

3515: l_init_msg_list := p_init_msg_list;
3516: END IF;
3517:
3518: IF FND_API.to_Boolean(l_init_msg_list) THEN
3519: FND_MSG_PUB.initialize;
3520: END IF;
3521:
3522: /*-----------------------------------------+
3523: | Initialize return status to SUCCESS |

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

3731: ROLLBACK TO Override_Tax_PVT;
3732: x_return_status := FND_API.G_RET_STS_ERROR ;
3733: DUMP_MSG;
3734: /*---------------------------------------------------------+
3735: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
3736: | in the message stack. If there is only one message in |
3737: | the stack it retrieves this message |
3738: +---------------------------------------------------------*/
3739: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

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

3735: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
3736: | in the message stack. If there is only one message in |
3737: | the stack it retrieves this message |
3738: +---------------------------------------------------------*/
3739: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
3740: p_count => x_msg_count,
3741: p_data => x_msg_data
3742: );
3743: IF ( G_LEVEL_ERROR >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 3762: FND_MSG_PUB.Add;

3758: ROLLBACK TO Override_Tax_PVT;
3759: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
3760: DUMP_MSG;
3761: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
3762: FND_MSG_PUB.Add;
3763: /*---------------------------------------------------------+
3764: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
3765: | in the message stack. If there is only one message in |
3766: | the stack it retrieves this message |

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

3760: DUMP_MSG;
3761: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
3762: FND_MSG_PUB.Add;
3763: /*---------------------------------------------------------+
3764: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
3765: | in the message stack. If there is only one message in |
3766: | the stack it retrieves this message |
3767: +---------------------------------------------------------*/
3768: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

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

3764: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
3765: | in the message stack. If there is only one message in |
3766: | the stack it retrieves this message |
3767: +---------------------------------------------------------*/
3768: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
3769: p_count => x_msg_count,
3770: p_data => x_msg_data
3771: );
3772: IF ( G_LEVEL_ERROR >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 3790: FND_MSG_PUB.Add;

3786: WHEN OTHERS THEN
3787: ROLLBACK TO Override_Tax_PVT;
3788: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
3789: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
3790: FND_MSG_PUB.Add;
3791: /*---------------------------------------------------------+
3792: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
3793: | in the message stack. If there is only one message in |
3794: | the stack it retrieves this message |

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

3788: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
3789: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
3790: FND_MSG_PUB.Add;
3791: /*---------------------------------------------------------+
3792: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
3793: | in the message stack. If there is only one message in |
3794: | the stack it retrieves this message |
3795: +---------------------------------------------------------*/
3796: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

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

3792: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
3793: | in the message stack. If there is only one message in |
3794: | the stack it retrieves this message |
3795: +---------------------------------------------------------*/
3796: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
3797: p_count => x_msg_count,
3798: p_data => x_msg_data
3799: );
3800:

Line 3867: FND_MSG_PUB.initialize;

3863: l_init_msg_list := p_init_msg_list;
3864: END IF;
3865:
3866: IF FND_API.to_Boolean(l_init_msg_list) THEN
3867: FND_MSG_PUB.initialize;
3868: END IF;
3869:
3870: /*-----------------------------------------+
3871: | Initialize return status to SUCCESS |

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

3916: ROLLBACK TO global_document_update_PVT;
3917: x_return_status := FND_API.G_RET_STS_ERROR ;
3918: DUMP_MSG;
3919: /*---------------------------------------------------------+
3920: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
3921: | in the message stack. If there is only one message in |
3922: | the stack it retrieves this message |
3923: +---------------------------------------------------------*/
3924: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

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

3920: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
3921: | in the message stack. If there is only one message in |
3922: | the stack it retrieves this message |
3923: +---------------------------------------------------------*/
3924: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
3925: p_count => x_msg_count,
3926: p_data => x_msg_data
3927: );
3928: IF ( G_LEVEL_ERROR >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 3937: FND_MSG_PUB.Add;

3933: ROLLBACK TO global_document_update_PVT;
3934: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
3935: DUMP_MSG;
3936: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
3937: FND_MSG_PUB.Add;
3938: /*---------------------------------------------------------+
3939: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
3940: | in the message stack. If there is only one message in |
3941: | the stack it retrieves this message |

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

3935: DUMP_MSG;
3936: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
3937: FND_MSG_PUB.Add;
3938: /*---------------------------------------------------------+
3939: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
3940: | in the message stack. If there is only one message in |
3941: | the stack it retrieves this message |
3942: +---------------------------------------------------------*/
3943: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

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

3939: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
3940: | in the message stack. If there is only one message in |
3941: | the stack it retrieves this message |
3942: +---------------------------------------------------------*/
3943: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
3944: p_count => x_msg_count,
3945: p_data => x_msg_data
3946: );
3947: IF ( G_LEVEL_ERROR >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 3955: FND_MSG_PUB.Add;

3951: WHEN OTHERS THEN
3952: ROLLBACK TO global_document_update_PVT;
3953: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
3954: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
3955: FND_MSG_PUB.Add;
3956: /*---------------------------------------------------------+
3957: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
3958: | in the message stack. If there is only one message in |
3959: | the stack it retrieves this message |

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

3953: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
3954: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
3955: FND_MSG_PUB.Add;
3956: /*---------------------------------------------------------+
3957: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
3958: | in the message stack. If there is only one message in |
3959: | the stack it retrieves this message |
3960: +---------------------------------------------------------*/
3961: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

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

3957: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
3958: | in the message stack. If there is only one message in |
3959: | the stack it retrieves this message |
3960: +---------------------------------------------------------*/
3961: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
3962: p_count => x_msg_count,
3963: p_data => x_msg_data
3964: );
3965:

Line 4029: FND_MSG_PUB.initialize;

4025: l_init_msg_list := p_init_msg_list;
4026: END IF;
4027:
4028: IF FND_API.to_Boolean(l_init_msg_list) THEN
4029: FND_MSG_PUB.initialize;
4030: END IF;
4031:
4032: /*-----------------------------------------+
4033: | Initialize return status to SUCCESS |

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

4249: ROLLBACK TO global_document_update_PVT;
4250: x_return_status := FND_API.G_RET_STS_ERROR ;
4251: DUMP_MSG;
4252: /*---------------------------------------------------------+
4253: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
4254: | in the message stack. If there is only one message in |
4255: | the stack it retrieves this message |
4256: +---------------------------------------------------------*/
4257: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

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

4253: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
4254: | in the message stack. If there is only one message in |
4255: | the stack it retrieves this message |
4256: +---------------------------------------------------------*/
4257: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
4258: p_count => x_msg_count,
4259: p_data => x_msg_data
4260: );
4261: IF ( G_LEVEL_ERROR >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 4270: FND_MSG_PUB.Add;

4266: ROLLBACK TO global_document_update_PVT;
4267: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
4268: DUMP_MSG;
4269: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
4270: FND_MSG_PUB.Add;
4271: /*---------------------------------------------------------+
4272: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
4273: | in the message stack. If there is only one message in |
4274: | the stack it retrieves this message |

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

4268: DUMP_MSG;
4269: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
4270: FND_MSG_PUB.Add;
4271: /*---------------------------------------------------------+
4272: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
4273: | in the message stack. If there is only one message in |
4274: | the stack it retrieves this message |
4275: +---------------------------------------------------------*/
4276: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

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

4272: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
4273: | in the message stack. If there is only one message in |
4274: | the stack it retrieves this message |
4275: +---------------------------------------------------------*/
4276: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
4277: p_count => x_msg_count,
4278: p_data => x_msg_data
4279: );
4280:

Line 4289: FND_MSG_PUB.Add;

4285: WHEN OTHERS THEN
4286: ROLLBACK TO global_document_update_PVT;
4287: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
4288: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
4289: FND_MSG_PUB.Add;
4290: /*---------------------------------------------------------+
4291: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
4292: | in the message stack. If there is only one message in |
4293: | the stack it retrieves this message |

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

4287: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
4288: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
4289: FND_MSG_PUB.Add;
4290: /*---------------------------------------------------------+
4291: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
4292: | in the message stack. If there is only one message in |
4293: | the stack it retrieves this message |
4294: +---------------------------------------------------------*/
4295: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

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

4291: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
4292: | in the message stack. If there is only one message in |
4293: | the stack it retrieves this message |
4294: +---------------------------------------------------------*/
4295: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
4296: p_count => x_msg_count,
4297: p_data => x_msg_data
4298: );
4299: IF ( G_LEVEL_UNEXPECTED >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 4355: FND_MSG_PUB.initialize;

4351: l_init_msg_list := p_init_msg_list;
4352: END IF;
4353:
4354: IF FND_API.to_Boolean(l_init_msg_list) THEN
4355: FND_MSG_PUB.initialize;
4356: END IF;
4357:
4358: /*-----------------------------------------+
4359: | Initialize return status to SUCCESS |

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

4453: ROLLBACK TO mark_tax_lines_del_PVT;
4454: x_return_status := FND_API.G_RET_STS_ERROR ;
4455: DUMP_MSG;
4456: /*---------------------------------------------------------+
4457: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
4458: | in the message stack. If there is only one message in |
4459: | the stack it retrieves this message |
4460: +---------------------------------------------------------*/
4461: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

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

4457: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
4458: | in the message stack. If there is only one message in |
4459: | the stack it retrieves this message |
4460: +---------------------------------------------------------*/
4461: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
4462: p_count => x_msg_count,
4463: p_data => x_msg_data
4464: );
4465: IF ( G_LEVEL_ERROR >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 4474: FND_MSG_PUB.Add;

4470: ROLLBACK TO mark_tax_lines_del_PVT;
4471: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
4472: DUMP_MSG;
4473: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
4474: FND_MSG_PUB.Add;
4475: /*---------------------------------------------------------+
4476: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
4477: | in the message stack. If there is only one message in |
4478: | the stack it retrieves this message |

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

4472: DUMP_MSG;
4473: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
4474: FND_MSG_PUB.Add;
4475: /*---------------------------------------------------------+
4476: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
4477: | in the message stack. If there is only one message in |
4478: | the stack it retrieves this message |
4479: +---------------------------------------------------------*/
4480: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

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

4476: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
4477: | in the message stack. If there is only one message in |
4478: | the stack it retrieves this message |
4479: +---------------------------------------------------------*/
4480: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
4481: p_count => x_msg_count,
4482: p_data => x_msg_data
4483: );
4484:

Line 4493: FND_MSG_PUB.Add;

4489: WHEN OTHERS THEN
4490: ROLLBACK TO mark_tax_lines_del_PVT;
4491: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
4492: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
4493: FND_MSG_PUB.Add;
4494: /*---------------------------------------------------------+
4495: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
4496: | in the message stack. If there is only one message in |
4497: | the stack it retrieves this message |

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

4491: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
4492: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
4493: FND_MSG_PUB.Add;
4494: /*---------------------------------------------------------+
4495: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
4496: | in the message stack. If there is only one message in |
4497: | the stack it retrieves this message |
4498: +---------------------------------------------------------*/
4499: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

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

4495: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
4496: | in the message stack. If there is only one message in |
4497: | the stack it retrieves this message |
4498: +---------------------------------------------------------*/
4499: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
4500: p_count => x_msg_count,
4501: p_data => x_msg_data
4502: );
4503: IF ( G_LEVEL_UNEXPECTED >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 4564: FND_MSG_PUB.initialize;

4560: l_init_msg_list := p_init_msg_list;
4561: END IF;
4562:
4563: IF FND_API.to_Boolean(l_init_msg_list) THEN
4564: FND_MSG_PUB.initialize;
4565: END IF;
4566:
4567: /*-----------------------------------------+
4568: | Initialize return status to SUCCESS |

Line 4652: FND_MSG_PUB.Add;

4648: ROLLBACK TO reverse_document_PVT;
4649: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
4650: DUMP_MSG;
4651: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
4652: FND_MSG_PUB.Add;
4653: /*---------------------------------------------------------+
4654: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
4655: | in the message stack. If there is only one message in |
4656: | the stack it retrieves this message |

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

4650: DUMP_MSG;
4651: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
4652: FND_MSG_PUB.Add;
4653: /*---------------------------------------------------------+
4654: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
4655: | in the message stack. If there is only one message in |
4656: | the stack it retrieves this message |
4657: +---------------------------------------------------------*/
4658: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

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

4654: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
4655: | in the message stack. If there is only one message in |
4656: | the stack it retrieves this message |
4657: +---------------------------------------------------------*/
4658: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
4659: p_count => x_msg_count,
4660: p_data => x_msg_data
4661: );
4662:

Line 4671: FND_MSG_PUB.Add;

4667: WHEN OTHERS THEN
4668: ROLLBACK TO reverse_document_PVT;
4669: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
4670: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
4671: FND_MSG_PUB.Add;
4672: /*---------------------------------------------------------+
4673: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
4674: | in the message stack. If there is only one message in |
4675: | the stack it retrieves this message |

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

4669: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
4670: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
4671: FND_MSG_PUB.Add;
4672: /*---------------------------------------------------------+
4673: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
4674: | in the message stack. If there is only one message in |
4675: | the stack it retrieves this message |
4676: +---------------------------------------------------------*/
4677: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

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

4673: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
4674: | in the message stack. If there is only one message in |
4675: | the stack it retrieves this message |
4676: +---------------------------------------------------------*/
4677: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
4678: p_count => x_msg_count,
4679: p_data => x_msg_data
4680: );
4681:

Line 4738: FND_MSG_PUB.initialize;

4734: l_init_msg_list := p_init_msg_list;
4735: END IF;
4736:
4737: IF FND_API.to_Boolean(l_init_msg_list) THEN
4738: FND_MSG_PUB.initialize;
4739: END IF;
4740:
4741: /*-----------------------------------------+
4742: | Initialize return status to SUCCESS |

Line 4811: FND_MSG_PUB.ADD;

4807: ROLLBACK TO reverse_distributions_PVT;
4808: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
4809: DUMP_MSG;
4810: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
4811: FND_MSG_PUB.ADD;
4812: /*---------------------------------------------------------+
4813: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
4814: | in the message stack. If there is only one message in |
4815: | the stack it retrieves this message |

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

4809: DUMP_MSG;
4810: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
4811: FND_MSG_PUB.ADD;
4812: /*---------------------------------------------------------+
4813: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
4814: | in the message stack. If there is only one message in |
4815: | the stack it retrieves this message |
4816: +---------------------------------------------------------*/
4817: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

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

4813: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
4814: | in the message stack. If there is only one message in |
4815: | the stack it retrieves this message |
4816: +---------------------------------------------------------*/
4817: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
4818: p_count => x_msg_count,
4819: p_data => x_msg_data
4820: );
4821: IF ( G_LEVEL_ERROR >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 4829: FND_MSG_PUB.ADD;

4825: WHEN OTHERS THEN
4826: ROLLBACK TO reverse_distributions_PVT;
4827: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
4828: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
4829: FND_MSG_PUB.ADD;
4830: /*---------------------------------------------------------+
4831: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
4832: | in the message stack. If there is only one message in |
4833: | the stack it retrieves this message |

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

4827: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
4828: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
4829: FND_MSG_PUB.ADD;
4830: /*---------------------------------------------------------+
4831: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
4832: | in the message stack. If there is only one message in |
4833: | the stack it retrieves this message |
4834: +---------------------------------------------------------*/
4835: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

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

4831: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
4832: | in the message stack. If there is only one message in |
4833: | the stack it retrieves this message |
4834: +---------------------------------------------------------*/
4835: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
4836: p_count => x_msg_count,
4837: p_data => x_msg_data
4838: );
4839: IF ( G_LEVEL_UNEXPECTED >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 4895: FND_MSG_PUB.initialize;

4891: l_init_msg_list := p_init_msg_list;
4892: END IF;
4893:
4894: IF FND_API.to_Boolean(l_init_msg_list) THEN
4895: FND_MSG_PUB.initialize;
4896: END IF;
4897:
4898: /*-----------------------------------------+
4899: | Initialize return status to SUCCESS |

Line 5010: FND_MSG_PUB.ADD;

5006: ROLLBACK TO reverse_doc_distribution_PVT;
5007: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
5008: DUMP_MSG;
5009: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
5010: FND_MSG_PUB.ADD;
5011: /*---------------------------------------------------------+
5012: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
5013: | in the message stack. If there is only one message in |
5014: | the stack it retrieves this message |

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

5008: DUMP_MSG;
5009: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
5010: FND_MSG_PUB.ADD;
5011: /*---------------------------------------------------------+
5012: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
5013: | in the message stack. If there is only one message in |
5014: | the stack it retrieves this message |
5015: +---------------------------------------------------------*/
5016: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

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

5012: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
5013: | in the message stack. If there is only one message in |
5014: | the stack it retrieves this message |
5015: +---------------------------------------------------------*/
5016: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
5017: p_count => x_msg_count,
5018: p_data => x_msg_data
5019: );
5020: IF ( G_LEVEL_ERROR >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 5028: FND_MSG_PUB.ADD;

5024: WHEN OTHERS THEN
5025: ROLLBACK TO reverse_doc_distribution_PVT;
5026: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
5027: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
5028: FND_MSG_PUB.ADD;
5029: /*---------------------------------------------------------+
5030: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
5031: | in the message stack. If there is only one message in |
5032: | the stack it retrieves this message |

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

5026: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
5027: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
5028: FND_MSG_PUB.ADD;
5029: /*---------------------------------------------------------+
5030: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
5031: | in the message stack. If there is only one message in |
5032: | the stack it retrieves this message |
5033: +---------------------------------------------------------*/
5034: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

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

5030: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
5031: | in the message stack. If there is only one message in |
5032: | the stack it retrieves this message |
5033: +---------------------------------------------------------*/
5034: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
5035: p_count => x_msg_count,
5036: p_data => x_msg_data
5037: );
5038: IF ( G_LEVEL_UNEXPECTED >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 5233: FND_MSG_PUB.initialize;

5229: l_init_msg_list := p_init_msg_list;
5230: END IF;
5231:
5232: IF FND_API.to_Boolean(l_init_msg_list) THEN
5233: FND_MSG_PUB.initialize;
5234: END IF;
5235:
5236: /*-----------------------------------------+
5237: | Initialize return status to SUCCESS |

Line 5849: FND_MSG_PUB.Add;

5845: END IF;
5846:
5847: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
5848: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
5849: FND_MSG_PUB.Add;
5850:
5851: IF c_HEADERS%ISOPEN THEN
5852: close c_HEADERS;
5853: END IF;

Line 5962: FND_MSG_PUB.Add;

5958: IF headers%ISOPEN THEN CLOSE headers; END IF;
5959: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
5960: DUMP_MSG;
5961: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
5962: FND_MSG_PUB.Add;
5963: /*---------------------------------------------------------+
5964: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
5965: | in the message stack. If there is only one message in |
5966: | the stack it retrieves this message |

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

5960: DUMP_MSG;
5961: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
5962: FND_MSG_PUB.Add;
5963: /*---------------------------------------------------------+
5964: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
5965: | in the message stack. If there is only one message in |
5966: | the stack it retrieves this message |
5967: +---------------------------------------------------------*/
5968: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

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

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

Line 6019: FND_MSG_PUB.Add;

6015: --Close all open cursors
6016: IF headers%ISOPEN THEN CLOSE headers; END IF;
6017: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
6018: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
6019: FND_MSG_PUB.Add;
6020: /*---------------------------------------------------------+
6021: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
6022: | in the message stack. If there is only one message in |
6023: | the stack it retrieves this message |

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

6017: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
6018: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
6019: FND_MSG_PUB.Add;
6020: /*---------------------------------------------------------+
6021: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
6022: | in the message stack. If there is only one message in |
6023: | the stack it retrieves this message |
6024: +---------------------------------------------------------*/
6025: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

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

6021: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
6022: | in the message stack. If there is only one message in |
6023: | the stack it retrieves this message |
6024: +---------------------------------------------------------*/
6025: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
6026: p_count => x_msg_count,
6027: p_data => x_msg_data
6028: );
6029: l_end_time:=SYSDATE;

Line 6120: FND_MSG_PUB.initialize;

6116: l_init_msg_list := p_init_msg_list;
6117: END IF;
6118:
6119: IF FND_API.to_Boolean(l_init_msg_list) THEN
6120: FND_MSG_PUB.initialize;
6121: END IF;
6122:
6123: /*-----------------------------------------+
6124: | Initialize return status to SUCCESS |

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

6213: ROLLBACK TO override_recovery_PVT;
6214: x_return_status := FND_API.G_RET_STS_ERROR ;
6215: DUMP_MSG;
6216: /*---------------------------------------------------------+
6217: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
6218: | in the message stack. If there is only one message in |
6219: | the stack it retrieves this message |
6220: +---------------------------------------------------------*/
6221: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

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

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

Line 6234: FND_MSG_PUB.Add;

6230: ROLLBACK TO override_recovery_PVT;
6231: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
6232: DUMP_MSG;
6233: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
6234: FND_MSG_PUB.Add;
6235: /*---------------------------------------------------------+
6236: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
6237: | in the message stack. If there is only one message in |
6238: | the stack it retrieves this message |

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

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

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

6236: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
6237: | in the message stack. If there is only one message in |
6238: | the stack it retrieves this message |
6239: +---------------------------------------------------------*/
6240: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
6241: p_count => x_msg_count,
6242: p_data => x_msg_data
6243: );
6244: IF ( G_LEVEL_ERROR >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 6257: FND_MSG_PUB.Add;

6253: +-------------------------------------------------------*/
6254: ROLLBACK TO override_recovery_PVT;
6255: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
6256: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
6257: FND_MSG_PUB.Add;
6258: /*---------------------------------------------------------+
6259: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
6260: | in the message stack. If there is only one message in |
6261: | the stack it retrieves this message |

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

6255: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
6256: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
6257: FND_MSG_PUB.Add;
6258: /*---------------------------------------------------------+
6259: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
6260: | in the message stack. If there is only one message in |
6261: | the stack it retrieves this message |
6262: +---------------------------------------------------------*/
6263: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

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

6259: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
6260: | in the message stack. If there is only one message in |
6261: | the stack it retrieves this message |
6262: +---------------------------------------------------------*/
6263: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
6264: p_count => x_msg_count,
6265: p_data => x_msg_data
6266: );
6267: IF ( G_LEVEL_UNEXPECTED >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 6350: FND_MSG_PUB.initialize;

6346: l_init_msg_list := p_init_msg_list;
6347: END IF;
6348:
6349: IF FND_API.to_Boolean(l_init_msg_list) THEN
6350: FND_MSG_PUB.initialize;
6351: END IF;
6352:
6353: /*-----------------------------------------+
6354: | Initialize return status to SUCCESS |

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

6470: ROLLBACK TO FREEZE_TAX_DISTRIBUTIONS_PVT;
6471: x_return_status := FND_API.G_RET_STS_ERROR ;
6472: DUMP_MSG;
6473: /*---------------------------------------------------------+
6474: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
6475: | in the message stack. If there is only one message in |
6476: | the stack it retrieves this message |
6477: +---------------------------------------------------------*/
6478: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

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

6474: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
6475: | in the message stack. If there is only one message in |
6476: | the stack it retrieves this message |
6477: +---------------------------------------------------------*/
6478: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
6479: p_count => x_msg_count,
6480: p_data => x_msg_data
6481: );
6482:

Line 6492: FND_MSG_PUB.Add;

6488: ROLLBACK TO FREEZE_TAX_DISTRIBUTIONS_PVT;
6489: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
6490: DUMP_MSG;
6491: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
6492: FND_MSG_PUB.Add;
6493: /*---------------------------------------------------------+
6494: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
6495: | in the message stack. If there is only one message in |
6496: | the stack it retrieves this message |

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

6490: DUMP_MSG;
6491: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
6492: FND_MSG_PUB.Add;
6493: /*---------------------------------------------------------+
6494: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
6495: | in the message stack. If there is only one message in |
6496: | the stack it retrieves this message |
6497: +---------------------------------------------------------*/
6498: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

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

6494: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
6495: | in the message stack. If there is only one message in |
6496: | the stack it retrieves this message |
6497: +---------------------------------------------------------*/
6498: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
6499: p_count => x_msg_count,
6500: p_data => x_msg_data
6501: );
6502: IF ( G_LEVEL_ERROR >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 6510: FND_MSG_PUB.Add;

6506: WHEN OTHERS THEN
6507: ROLLBACK TO FREEZE_TAX_DISTRIBUTIONS_PVT;
6508: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
6509: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
6510: FND_MSG_PUB.Add;
6511: /*---------------------------------------------------------+
6512: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
6513: | in the message stack. If there is only one message in |
6514: | the stack it retrieves this message |

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

6508: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
6509: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
6510: FND_MSG_PUB.Add;
6511: /*---------------------------------------------------------+
6512: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
6513: | in the message stack. If there is only one message in |
6514: | the stack it retrieves this message |
6515: +---------------------------------------------------------*/
6516: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

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

6512: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
6513: | in the message stack. If there is only one message in |
6514: | the stack it retrieves this message |
6515: +---------------------------------------------------------*/
6516: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
6517: p_count => x_msg_count,
6518: p_data => x_msg_data
6519: );
6520: IF ( G_LEVEL_UNEXPECTED >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 6585: FND_MSG_PUB.initialize;

6581: l_init_msg_list := p_init_msg_list;
6582: END IF;
6583:
6584: IF FND_API.to_Boolean(l_init_msg_list) THEN
6585: FND_MSG_PUB.initialize;
6586: END IF;
6587:
6588: /*-----------------------------------------+
6589: | Populate Global Variable |

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

6778: ROLLBACK TO Get_Tax_Distribution_Ccids_PVT;
6779: x_return_status := FND_API.G_RET_STS_ERROR ;
6780: DUMP_MSG;
6781: /*---------------------------------------------------------+
6782: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
6783: | in the message stack. If there is only one message in |
6784: | the stack it retrieves this message |
6785: +---------------------------------------------------------*/
6786: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

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

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

Line 6802: FND_MSG_PUB.Add;

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

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

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

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

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

Line 6820: FND_MSG_PUB.Add;

6816: WHEN OTHERS THEN
6817: ROLLBACK TO Get_Tax_Distribution_Ccids_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 6890: FND_MSG_PUB.initialize;

6886: l_init_msg_list := p_init_msg_list;
6887: END IF;
6888:
6889: IF FND_API.to_Boolean(l_init_msg_list) THEN
6890: FND_MSG_PUB.initialize;
6891: END IF;
6892:
6893: /*-----------------------------------------+
6894: | Initialize return status to SUCCESS |

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

6931: ROLLBACK TO Update_Tax_Dist_Gl_Date_PVT;
6932: x_return_status := FND_API.G_RET_STS_ERROR ;
6933: DUMP_MSG;
6934: /*---------------------------------------------------------+
6935: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
6936: | in the message stack. If there is only one message in |
6937: | the stack it retrieves this message |
6938: +---------------------------------------------------------*/
6939: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

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

6935: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
6936: | in the message stack. If there is only one message in |
6937: | the stack it retrieves this message |
6938: +---------------------------------------------------------*/
6939: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
6940: p_count => x_msg_count,
6941: p_data => x_msg_data
6942: );
6943: IF ( G_LEVEL_ERROR >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 6952: FND_MSG_PUB.Add;

6948: ROLLBACK TO Update_Tax_Dist_GL_Date_PVT;
6949: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
6950: DUMP_MSG;
6951: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
6952: FND_MSG_PUB.Add;
6953: /*---------------------------------------------------------+
6954: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
6955: | in the message stack. If there is only one message in |
6956: | the stack it retrieves this message |

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

6950: DUMP_MSG;
6951: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
6952: FND_MSG_PUB.Add;
6953: /*---------------------------------------------------------+
6954: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
6955: | in the message stack. If there is only one message in |
6956: | the stack it retrieves this message |
6957: +---------------------------------------------------------*/
6958: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

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

6954: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
6955: | in the message stack. If there is only one message in |
6956: | the stack it retrieves this message |
6957: +---------------------------------------------------------*/
6958: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
6959: p_count => x_msg_count,
6960: p_data => x_msg_data
6961: );
6962: IF ( G_LEVEL_ERROR >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 6970: FND_MSG_PUB.Add;

6966: WHEN OTHERS THEN
6967: ROLLBACK TO Update_tax_dist_gl_date_PVT;
6968: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
6969: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
6970: FND_MSG_PUB.Add;
6971: /*---------------------------------------------------------+
6972: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
6973: | in the message stack. If there is only one message in |
6974: | the stack it retrieves this message |

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

6968: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
6969: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
6970: FND_MSG_PUB.Add;
6971: /*---------------------------------------------------------+
6972: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
6973: | in the message stack. If there is only one message in |
6974: | the stack it retrieves this message |
6975: +---------------------------------------------------------*/
6976: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

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

6972: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
6973: | in the message stack. If there is only one message in |
6974: | the stack it retrieves this message |
6975: +---------------------------------------------------------*/
6976: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
6977: p_count => x_msg_count,
6978: p_data => x_msg_data
6979: );
6980: IF ( G_LEVEL_UNEXPECTED >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 7042: FND_MSG_PUB.initialize;

7038: l_init_msg_list := p_init_msg_list;
7039: END IF;
7040:
7041: IF FND_API.to_Boolean(l_init_msg_list) THEN
7042: FND_MSG_PUB.initialize;
7043: END IF;
7044:
7045: /*-----------------------------------------+
7046: | Initialize return status to SUCCESS |

Line 7064: FND_MSG_PUB.Add;

7060: | Missing Currency Conversion Rate |
7061: +---------------------------------------------*/
7062: IF p_curr_conv_rate is NULL THEN
7063: FND_MESSAGE.SET_NAME('ZX','ZX_CURRENCY_CONVERSION_RATE_REQD');
7064: FND_MSG_PUB.Add;
7065: IF ( G_LEVEL_STATEMENT >= G_CURRENT_RUNTIME_LEVEL) THEN
7066: FND_LOG.STRING(G_LEVEL_STATEMENT,G_MODULE_NAME||l_api_name,G_PKG_NAME||': '||l_api_name||
7067: 'Currency conversion rate is passed as null');
7068: END IF;

Line 7077: FND_MSG_PUB.Add;

7073: | Missing Currency Conversion Date |
7074: +---------------------------------------------*/
7075: IF p_curr_conv_date is NULL THEN
7076: FND_MESSAGE.SET_NAME('ZX','ZX_CURRENCY_CONVERSION_DATE_REQD');
7077: FND_MSG_PUB.Add;
7078: IF ( G_LEVEL_STATEMENT >= G_CURRENT_RUNTIME_LEVEL) THEN
7079: FND_LOG.STRING(G_LEVEL_STATEMENT,G_MODULE_NAME||l_api_name,G_PKG_NAME||': '||l_api_name||
7080: 'Currency conversion date is passed as null');
7081: END IF;

Line 7090: FND_MSG_PUB.Add;

7086: | Missing Currency Conversion Type |
7087: +---------------------------------------------*/
7088: IF p_curr_conv_type is NULL THEN
7089: FND_MESSAGE.SET_NAME('ZX','ZX_CURRENCY_CONVERSION_TYPE_REQD');
7090: FND_MSG_PUB.Add;
7091: IF ( G_LEVEL_STATEMENT >= G_CURRENT_RUNTIME_LEVEL) THEN
7092: FND_LOG.STRING(G_LEVEL_STATEMENT,G_MODULE_NAME||l_api_name,G_PKG_NAME||': '||l_api_name||
7093: 'Currency conversion type is passed as null');
7094: END IF;

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

7205: ROLLBACK TO Update_Exchange_Rate_PVT;
7206: x_return_status := FND_API.G_RET_STS_ERROR ;
7207: DUMP_MSG;
7208: /*---------------------------------------------------------+
7209: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
7210: | in the message stack. If there is only one message in |
7211: | the stack it retrieves this message |
7212: +---------------------------------------------------------*/
7213: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

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

7209: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
7210: | in the message stack. If there is only one message in |
7211: | the stack it retrieves this message |
7212: +---------------------------------------------------------*/
7213: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
7214: p_count => x_msg_count,
7215: p_data => x_msg_data
7216: );
7217:

Line 7227: FND_MSG_PUB.Add;

7223: ROLLBACK TO Update_Exchange_Rate_PVT;
7224: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
7225: DUMP_MSG;
7226: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
7227: FND_MSG_PUB.Add;
7228: /*---------------------------------------------------------+
7229: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
7230: | in the message stack. If there is only one message in |
7231: | the stack it retrieves this message |

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

7225: DUMP_MSG;
7226: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
7227: FND_MSG_PUB.Add;
7228: /*---------------------------------------------------------+
7229: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
7230: | in the message stack. If there is only one message in |
7231: | the stack it retrieves this message |
7232: +---------------------------------------------------------*/
7233: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

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

7229: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
7230: | in the message stack. If there is only one message in |
7231: | the stack it retrieves this message |
7232: +---------------------------------------------------------*/
7233: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
7234: p_count => x_msg_count,
7235: p_data => x_msg_data
7236: );
7237: IF ( G_LEVEL_ERROR >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 7245: FND_MSG_PUB.Add;

7241: WHEN OTHERS THEN
7242: ROLLBACK TO Update_Exchange_Rate_PVT;
7243: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
7244: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
7245: FND_MSG_PUB.Add;
7246: /*---------------------------------------------------------+
7247: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
7248: | in the message stack. If there is only one message in |
7249: | the stack it retrieves this message |

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

7243: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
7244: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
7245: FND_MSG_PUB.Add;
7246: /*---------------------------------------------------------+
7247: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
7248: | in the message stack. If there is only one message in |
7249: | the stack it retrieves this message |
7250: +---------------------------------------------------------*/
7251: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

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

7247: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
7248: | in the message stack. If there is only one message in |
7249: | the stack it retrieves this message |
7250: +---------------------------------------------------------*/
7251: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
7252: p_count => x_msg_count,
7253: p_data => x_msg_data
7254: );
7255:

Line 7322: FND_MSG_PUB.initialize;

7318: l_init_msg_list := p_init_msg_list;
7319: END IF;
7320:
7321: IF FND_API.to_Boolean(l_init_msg_list) THEN
7322: FND_MSG_PUB.initialize;
7323: END IF;
7324:
7325: /*-----------------------------------------+
7326: | Initialize return status to SUCCESS |

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

7419: ROLLBACK TO discard_tax_only_lines_PVT;
7420: x_return_status := FND_API.G_RET_STS_ERROR ;
7421: DUMP_MSG;
7422: /*---------------------------------------------------------+
7423: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
7424: | in the message stack. If there is only one message in |
7425: | the stack it retrieves this message |
7426: +---------------------------------------------------------*/
7427: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

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

7423: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
7424: | in the message stack. If there is only one message in |
7425: | the stack it retrieves this message |
7426: +---------------------------------------------------------*/
7427: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
7428: p_count => x_msg_count,
7429: p_data => x_msg_data
7430: );
7431: IF ( G_LEVEL_ERROR >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 7440: FND_MSG_PUB.Add;

7436: ROLLBACK TO discard_tax_only_lines_PVT;
7437: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
7438: DUMP_MSG;
7439: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
7440: FND_MSG_PUB.Add;
7441: /*---------------------------------------------------------+
7442: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
7443: | in the message stack. If there is only one message in |
7444: | the stack it retrieves this message |

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

7438: DUMP_MSG;
7439: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
7440: FND_MSG_PUB.Add;
7441: /*---------------------------------------------------------+
7442: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
7443: | in the message stack. If there is only one message in |
7444: | the stack it retrieves this message |
7445: +---------------------------------------------------------*/
7446: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

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

7442: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
7443: | in the message stack. If there is only one message in |
7444: | the stack it retrieves this message |
7445: +---------------------------------------------------------*/
7446: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
7447: p_count => x_msg_count,
7448: p_data => x_msg_data
7449: );
7450: IF ( G_LEVEL_ERROR >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 7458: FND_MSG_PUB.Add;

7454: WHEN OTHERS THEN
7455: ROLLBACK TO discard_tax_only_lines_PVT;
7456: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
7457: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
7458: FND_MSG_PUB.Add;
7459: /*---------------------------------------------------------+
7460: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
7461: | in the message stack. If there is only one message in |
7462: | the stack it retrieves this message |

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

7456: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
7457: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
7458: FND_MSG_PUB.Add;
7459: /*---------------------------------------------------------+
7460: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
7461: | in the message stack. If there is only one message in |
7462: | the stack it retrieves this message |
7463: +---------------------------------------------------------*/
7464: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

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

7460: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
7461: | in the message stack. If there is only one message in |
7462: | the stack it retrieves this message |
7463: +---------------------------------------------------------*/
7464: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
7465: p_count => x_msg_count,
7466: p_data => x_msg_data
7467: );
7468: IF ( G_LEVEL_UNEXPECTED >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 7531: FND_MSG_PUB.initialize;

7527: l_init_msg_list := p_init_msg_list;
7528: END IF;
7529:
7530: IF FND_API.to_Boolean(l_init_msg_list) THEN
7531: FND_MSG_PUB.initialize;
7532: END IF;
7533:
7534: /*-----------------------------------------+
7535: | Initialize return status to SUCCESS |

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

7649: ROLLBACK TO Validate_Document_PVT;
7650: x_return_status := FND_API.G_RET_STS_ERROR ;
7651: DUMP_MSG;
7652: /*---------------------------------------------------------+
7653: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
7654: | in the message stack. If there is only one message in |
7655: | the stack it retrieves this message |
7656: +---------------------------------------------------------*/
7657: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

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

7653: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
7654: | in the message stack. If there is only one message in |
7655: | the stack it retrieves this message |
7656: +---------------------------------------------------------*/
7657: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
7658: p_count => x_msg_count,
7659: p_data => x_msg_data
7660: );
7661: IF ( G_LEVEL_ERROR >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 7670: FND_MSG_PUB.Add;

7666: ROLLBACK TO Validate_Document_PVT;
7667: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
7668: DUMP_MSG;
7669: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
7670: FND_MSG_PUB.Add;
7671: /*---------------------------------------------------------+
7672: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
7673: | in the message stack. If there is only one message in |
7674: | the stack it retrieves this message |

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

7668: DUMP_MSG;
7669: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
7670: FND_MSG_PUB.Add;
7671: /*---------------------------------------------------------+
7672: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
7673: | in the message stack. If there is only one message in |
7674: | the stack it retrieves this message |
7675: +---------------------------------------------------------*/
7676: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

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

7672: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
7673: | in the message stack. If there is only one message in |
7674: | the stack it retrieves this message |
7675: +---------------------------------------------------------*/
7676: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
7677: p_count => x_msg_count,
7678: p_data => x_msg_data
7679: );
7680: IF ( G_LEVEL_ERROR >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 7689: FND_MSG_PUB.Add;

7685: WHEN OTHERS THEN
7686: ROLLBACK TO Validate_Document_PVT;
7687: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
7688: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
7689: FND_MSG_PUB.Add;
7690: /*---------------------------------------------------------+
7691: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
7692: | in the message stack. If there is only one message in |
7693: | the stack it retrieves this message |

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

7687: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
7688: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
7689: FND_MSG_PUB.Add;
7690: /*---------------------------------------------------------+
7691: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
7692: | in the message stack. If there is only one message in |
7693: | the stack it retrieves this message |
7694: +---------------------------------------------------------*/
7695: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

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

7691: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
7692: | in the message stack. If there is only one message in |
7693: | the stack it retrieves this message |
7694: +---------------------------------------------------------*/
7695: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
7696: p_count => x_msg_count,
7697: p_data => x_msg_data
7698: );
7699:

Line 7792: FND_MSG_PUB.initialize;

7788: l_init_msg_list := p_init_msg_list;
7789: END IF;
7790:
7791: IF FND_API.to_Boolean(l_init_msg_list) THEN
7792: FND_MSG_PUB.initialize;
7793: END IF;
7794:
7795: /*-----------------------------------------+
7796: | Initialize return status to SUCCESS |

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

7841: ROLLBACK TO Validate_Document_PVT;
7842: x_return_status := FND_API.G_RET_STS_ERROR ;
7843: DUMP_MSG;
7844: /*---------------------------------------------------------+
7845: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
7846: | in the message stack. If there is only one message in |
7847: | the stack it retrieves this message |
7848: +---------------------------------------------------------*/
7849: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

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

7845: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
7846: | in the message stack. If there is only one message in |
7847: | the stack it retrieves this message |
7848: +---------------------------------------------------------*/
7849: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
7850: p_count => x_msg_count,
7851: p_data => x_msg_data
7852: );
7853: IF ( G_LEVEL_ERROR >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 7862: FND_MSG_PUB.Add;

7858: ROLLBACK TO Validate_Document_PVT;
7859: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
7860: DUMP_MSG;
7861: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
7862: FND_MSG_PUB.Add;
7863: /*---------------------------------------------------------+
7864: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
7865: | in the message stack. If there is only one message in |
7866: | the stack it retrieves this message |

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

7860: DUMP_MSG;
7861: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
7862: FND_MSG_PUB.Add;
7863: /*---------------------------------------------------------+
7864: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
7865: | in the message stack. If there is only one message in |
7866: | the stack it retrieves this message |
7867: +---------------------------------------------------------*/
7868: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

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

7864: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
7865: | in the message stack. If there is only one message in |
7866: | the stack it retrieves this message |
7867: +---------------------------------------------------------*/
7868: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
7869: p_count => x_msg_count,
7870: p_data => x_msg_data
7871: );
7872: IF ( G_LEVEL_ERROR >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 7881: FND_MSG_PUB.Add;

7877: WHEN OTHERS THEN
7878: ROLLBACK TO Validate_Document_PVT;
7879: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
7880: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
7881: FND_MSG_PUB.Add;
7882: /*---------------------------------------------------------+
7883: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
7884: | in the message stack. If there is only one message in |
7885: | the stack it retrieves this message |

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

7879: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
7880: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
7881: FND_MSG_PUB.Add;
7882: /*---------------------------------------------------------+
7883: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
7884: | in the message stack. If there is only one message in |
7885: | the stack it retrieves this message |
7886: +---------------------------------------------------------*/
7887: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

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

7883: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
7884: | in the message stack. If there is only one message in |
7885: | the stack it retrieves this message |
7886: +---------------------------------------------------------*/
7887: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
7888: p_count => x_msg_count,
7889: p_data => x_msg_data
7890: );
7891:

Line 7956: FND_MSG_PUB.initialize;

7952: l_init_msg_list := p_init_msg_list;
7953: END IF;
7954:
7955: IF FND_API.to_Boolean(l_init_msg_list) THEN
7956: FND_MSG_PUB.initialize;
7957: END IF;
7958:
7959:
7960: /*-----------------------------------------+

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

8001: ROLLBACK TO Get_Default_Tax_Line_Attrs_PVT;
8002: x_return_status := FND_API.G_RET_STS_ERROR ;
8003: DUMP_MSG;
8004: /*---------------------------------------------------------+
8005: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
8006: | in the message stack. If there is only one message in |
8007: | the stack it retrieves this message |
8008: +---------------------------------------------------------*/
8009: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

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

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

Line 8022: FND_MSG_PUB.Add;

8018: ROLLBACK TO Get_Default_Tax_Line_Attrs_PVT;
8019: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
8020: DUMP_MSG;
8021: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
8022: FND_MSG_PUB.Add;
8023: /*---------------------------------------------------------+
8024: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
8025: | in the message stack. If there is only one message in |
8026: | the stack it retrieves this message |

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

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

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

8024: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
8025: | in the message stack. If there is only one message in |
8026: | the stack it retrieves this message |
8027: +---------------------------------------------------------*/
8028: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
8029: p_count => x_msg_count,
8030: p_data => x_msg_data
8031: );
8032: IF ( G_LEVEL_ERROR >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 8040: FND_MSG_PUB.Add;

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

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

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

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

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

Line 8197: FND_MSG_PUB.initialize;

8193: l_init_msg_list := p_init_msg_list;
8194: END IF;
8195:
8196: IF FND_API.to_Boolean(l_init_msg_list) THEN
8197: FND_MSG_PUB.initialize;
8198: END IF;
8199:
8200: /*-----------------------------------------+
8201: | Initialize return status to SUCCESS |

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

8465: ROLLBACK TO Get_Default_Tax_Det_Attrs_PVT;
8466: x_return_status := FND_API.G_RET_STS_ERROR ;
8467: DUMP_MSG;
8468: /*---------------------------------------------------------+
8469: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
8470: | in the message stack. If there is only one message in |
8471: | the stack it retrieves this message |
8472: +---------------------------------------------------------*/
8473: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

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

8469: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
8470: | in the message stack. If there is only one message in |
8471: | the stack it retrieves this message |
8472: +---------------------------------------------------------*/
8473: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
8474: p_count => x_msg_count,
8475: p_data => x_msg_data
8476: );
8477: IF ( G_LEVEL_ERROR >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 8486: FND_MSG_PUB.Add;

8482: ROLLBACK TO Get_Default_Tax_Det_Attrs_PVT;
8483: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
8484: DUMP_MSG;
8485: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
8486: FND_MSG_PUB.Add;
8487: /*---------------------------------------------------------+
8488: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
8489: | in the message stack. If there is only one message in |
8490: | the stack it retrieves this message |

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

8484: DUMP_MSG;
8485: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
8486: FND_MSG_PUB.Add;
8487: /*---------------------------------------------------------+
8488: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
8489: | in the message stack. If there is only one message in |
8490: | the stack it retrieves this message |
8491: +---------------------------------------------------------*/
8492: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

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

8488: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
8489: | in the message stack. If there is only one message in |
8490: | the stack it retrieves this message |
8491: +---------------------------------------------------------*/
8492: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
8493: p_count => x_msg_count,
8494: p_data => x_msg_data
8495: );
8496:

Line 8505: FND_MSG_PUB.Add;

8501: WHEN OTHERS THEN
8502: ROLLBACK TO Get_Default_Tax_Det_Attrs_PVT;
8503: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
8504: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
8505: FND_MSG_PUB.Add;
8506: /*---------------------------------------------------------+
8507: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
8508: | in the message stack. If there is only one message in |
8509: | the stack it retrieves this message |

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

8503: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
8504: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
8505: FND_MSG_PUB.Add;
8506: /*---------------------------------------------------------+
8507: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
8508: | in the message stack. If there is only one message in |
8509: | the stack it retrieves this message |
8510: +---------------------------------------------------------*/
8511: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

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

8507: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
8508: | in the message stack. If there is only one message in |
8509: | the stack it retrieves this message |
8510: +---------------------------------------------------------*/
8511: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
8512: p_count => x_msg_count,
8513: p_data => x_msg_data
8514: );
8515: IF ( G_LEVEL_UNEXPECTED >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 8590: FND_MSG_PUB.initialize;

8586: l_init_msg_list := p_init_msg_list;
8587: END IF;
8588:
8589: IF FND_API.to_Boolean(l_init_msg_list) THEN
8590: FND_MSG_PUB.initialize;
8591: END IF;
8592:
8593: /*-----------------------------------------+
8594: | Initialize return status to SUCCESS |

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

8764: ROLLBACK TO Get_Default_Tax_Det_Attrs_PVT;
8765: x_return_status := FND_API.G_RET_STS_ERROR ;
8766: DUMP_MSG;
8767: /*---------------------------------------------------------+
8768: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
8769: | in the message stack. If there is only one message in |
8770: | the stack it retrieves this message |
8771: +---------------------------------------------------------*/
8772: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

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

8768: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
8769: | in the message stack. If there is only one message in |
8770: | the stack it retrieves this message |
8771: +---------------------------------------------------------*/
8772: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
8773: p_count => x_msg_count,
8774: p_data => x_msg_data
8775: );
8776: IF ( G_LEVEL_ERROR >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 8785: FND_MSG_PUB.Add;

8781: ROLLBACK TO Get_Default_Tax_Det_Attrs_PVT;
8782: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
8783: DUMP_MSG;
8784: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
8785: FND_MSG_PUB.Add;
8786: /*---------------------------------------------------------+
8787: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
8788: | in the message stack. If there is only one message in |
8789: | the stack it retrieves this message |

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

8783: DUMP_MSG;
8784: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
8785: FND_MSG_PUB.Add;
8786: /*---------------------------------------------------------+
8787: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
8788: | in the message stack. If there is only one message in |
8789: | the stack it retrieves this message |
8790: +---------------------------------------------------------*/
8791: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

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

8787: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
8788: | in the message stack. If there is only one message in |
8789: | the stack it retrieves this message |
8790: +---------------------------------------------------------*/
8791: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
8792: p_count => x_msg_count,
8793: p_data => x_msg_data
8794: );
8795:

Line 8804: FND_MSG_PUB.Add;

8800: WHEN OTHERS THEN
8801: ROLLBACK TO Get_Default_Tax_Det_Attrs_PVT;
8802: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
8803: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
8804: FND_MSG_PUB.Add;
8805: /*---------------------------------------------------------+
8806: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
8807: | in the message stack. If there is only one message in |
8808: | the stack it retrieves this message |

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

8802: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
8803: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
8804: FND_MSG_PUB.Add;
8805: /*---------------------------------------------------------+
8806: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
8807: | in the message stack. If there is only one message in |
8808: | the stack it retrieves this message |
8809: +---------------------------------------------------------*/
8810: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

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

8806: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
8807: | in the message stack. If there is only one message in |
8808: | the stack it retrieves this message |
8809: +---------------------------------------------------------*/
8810: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
8811: p_count => x_msg_count,
8812: p_data => x_msg_data
8813: );
8814: IF ( G_LEVEL_UNEXPECTED >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 8877: FND_MSG_PUB.initialize;

8873: l_init_msg_list := p_init_msg_list;
8874: END IF;
8875:
8876: IF FND_API.to_Boolean(l_init_msg_list) THEN
8877: FND_MSG_PUB.initialize;
8878: END IF;
8879:
8880: /*-----------------------------------------+
8881: | Initialize return status to SUCCESS |

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

8909: END IF;
8910: END IF;
8911:
8912: /*---------------------------------------------------------+
8913: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
8914: | in the message stack. If there is only one message in |
8915: | the stack it retrieves this message |
8916: +---------------------------------------------------------*/
8917: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

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

8913: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
8914: | in the message stack. If there is only one message in |
8915: | the stack it retrieves this message |
8916: +---------------------------------------------------------*/
8917: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
8918: p_count => x_msg_count,
8919: p_data => x_msg_data
8920: );
8921:

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

8928: ROLLBACK TO Set_Tax_Security_Context_PVT;
8929: x_return_status := FND_API.G_RET_STS_ERROR ;
8930: DUMP_MSG;
8931: /*---------------------------------------------------------+
8932: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
8933: | in the message stack. If there is only one message in |
8934: | the stack it retrieves this message |
8935: +---------------------------------------------------------*/
8936: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

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

8932: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
8933: | in the message stack. If there is only one message in |
8934: | the stack it retrieves this message |
8935: +---------------------------------------------------------*/
8936: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
8937: p_count => x_msg_count,
8938: p_data => x_msg_data
8939: );
8940:

Line 8950: FND_MSG_PUB.Add;

8946: ROLLBACK TO Set_Tax_Security_Context_PVT;
8947: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
8948: DUMP_MSG;
8949: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
8950: FND_MSG_PUB.Add;
8951: /*---------------------------------------------------------+
8952: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
8953: | in the message stack. If there is only one message in |
8954: | the stack it retrieves this message |

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

8948: DUMP_MSG;
8949: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
8950: FND_MSG_PUB.Add;
8951: /*---------------------------------------------------------+
8952: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
8953: | in the message stack. If there is only one message in |
8954: | the stack it retrieves this message |
8955: +---------------------------------------------------------*/
8956: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

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

8952: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
8953: | in the message stack. If there is only one message in |
8954: | the stack it retrieves this message |
8955: +---------------------------------------------------------*/
8956: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
8957: p_count => x_msg_count,
8958: p_data => x_msg_data
8959: );
8960:

Line 8969: FND_MSG_PUB.Add;

8965: WHEN OTHERS THEN
8966: ROLLBACK TO set_tax_security_context_PVT;
8967: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
8968: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
8969: FND_MSG_PUB.Add;
8970: /*---------------------------------------------------------+
8971: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
8972: | in the message stack. If there is only one message in |
8973: | the stack it retrieves this message |

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

8967: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
8968: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
8969: FND_MSG_PUB.Add;
8970: /*---------------------------------------------------------+
8971: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
8972: | in the message stack. If there is only one message in |
8973: | the stack it retrieves this message |
8974: +---------------------------------------------------------*/
8975: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

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

8971: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
8972: | in the message stack. If there is only one message in |
8973: | the stack it retrieves this message |
8974: +---------------------------------------------------------*/
8975: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
8976: p_count => x_msg_count,
8977: p_data => x_msg_data
8978: );
8979: IF ( G_LEVEL_UNEXPECTED >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 9042: FND_MSG_PUB.initialize;

9038: l_init_msg_list := p_init_msg_list;
9039: END IF;
9040:
9041: IF FND_API.to_Boolean(l_init_msg_list) THEN
9042: FND_MSG_PUB.initialize;
9043: END IF;
9044:
9045: /*-----------------------------------------+
9046: | Initialize return status to SUCCESS |

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

9073: END IF;
9074: END IF;
9075:
9076: /*---------------------------------------------------------+
9077: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
9078: | in the message stack. If there is only one message in |
9079: | the stack it retrieves this message |
9080: +---------------------------------------------------------*/
9081: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

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

9077: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
9078: | in the message stack. If there is only one message in |
9079: | the stack it retrieves this message |
9080: +---------------------------------------------------------*/
9081: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
9082: p_count => x_msg_count,
9083: p_data => x_msg_data
9084: );
9085:

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

9092: ROLLBACK TO Set_Tax_Security_Context_PVT;
9093: x_return_status := FND_API.G_RET_STS_ERROR ;
9094: DUMP_MSG;
9095: /*---------------------------------------------------------+
9096: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
9097: | in the message stack. If there is only one message in |
9098: | the stack it retrieves this message |
9099: +---------------------------------------------------------*/
9100: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

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

9096: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
9097: | in the message stack. If there is only one message in |
9098: | the stack it retrieves this message |
9099: +---------------------------------------------------------*/
9100: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
9101: p_count => x_msg_count,
9102: p_data => x_msg_data
9103: );
9104:

Line 9114: FND_MSG_PUB.Add;

9110: ROLLBACK TO Set_Tax_Security_Context_PVT;
9111: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
9112: DUMP_MSG;
9113: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
9114: FND_MSG_PUB.Add;
9115: /*---------------------------------------------------------+
9116: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
9117: | in the message stack. If there is only one message in |
9118: | the stack it retrieves this message |

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

9112: DUMP_MSG;
9113: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
9114: FND_MSG_PUB.Add;
9115: /*---------------------------------------------------------+
9116: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
9117: | in the message stack. If there is only one message in |
9118: | the stack it retrieves this message |
9119: +---------------------------------------------------------*/
9120: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

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

9116: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
9117: | in the message stack. If there is only one message in |
9118: | the stack it retrieves this message |
9119: +---------------------------------------------------------*/
9120: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
9121: p_count => x_msg_count,
9122: p_data => x_msg_data
9123: );
9124:

Line 9133: FND_MSG_PUB.Add;

9129: WHEN OTHERS THEN
9130: ROLLBACK TO set_tax_security_context_PVT;
9131: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
9132: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
9133: FND_MSG_PUB.Add;
9134: /*---------------------------------------------------------+
9135: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
9136: | in the message stack. If there is only one message in |
9137: | the stack it retrieves this message |

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

9131: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
9132: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
9133: FND_MSG_PUB.Add;
9134: /*---------------------------------------------------------+
9135: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
9136: | in the message stack. If there is only one message in |
9137: | the stack it retrieves this message |
9138: +---------------------------------------------------------*/
9139: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

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

9135: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
9136: | in the message stack. If there is only one message in |
9137: | the stack it retrieves this message |
9138: +---------------------------------------------------------*/
9139: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
9140: p_count => x_msg_count,
9141: p_data => x_msg_data
9142: );
9143: IF ( G_LEVEL_UNEXPECTED >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 9205: FND_MSG_PUB.initialize;

9201: l_init_msg_list := p_init_msg_list;
9202: END IF;
9203:
9204: IF FND_API.to_Boolean(l_init_msg_list) THEN
9205: FND_MSG_PUB.initialize;
9206: END IF;
9207:
9208: /*-----------------------------------------+
9209: | Initialize return status to SUCCESS |

Line 9313: FND_MSG_PUB.Add;

9309: ROLLBACK TO Validate_And_Default_Tax_Attr;
9310: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
9311: DUMP_MSG;
9312: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
9313: FND_MSG_PUB.Add;
9314: /*---------------------------------------------------------+
9315: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
9316: | in the message stack. If there is only one message in |
9317: | the stack it retrieves this message |

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

9311: DUMP_MSG;
9312: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
9313: FND_MSG_PUB.Add;
9314: /*---------------------------------------------------------+
9315: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
9316: | in the message stack. If there is only one message in |
9317: | the stack it retrieves this message |
9318: +---------------------------------------------------------*/
9319: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

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

9315: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
9316: | in the message stack. If there is only one message in |
9317: | the stack it retrieves this message |
9318: +---------------------------------------------------------*/
9319: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
9320: p_count => x_msg_count,
9321: p_data => x_msg_data
9322: );
9323:

Line 9332: FND_MSG_PUB.Add;

9328: WHEN OTHERS THEN
9329: ROLLBACK TO Validate_And_Default_Tax_Attr;
9330: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
9331: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
9332: FND_MSG_PUB.Add;
9333: /*---------------------------------------------------------+
9334: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
9335: | in the message stack. If there is only one message in |
9336: | the stack it retrieves this message |

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

9330: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
9331: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
9332: FND_MSG_PUB.Add;
9333: /*---------------------------------------------------------+
9334: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
9335: | in the message stack. If there is only one message in |
9336: | the stack it retrieves this message |
9337: +---------------------------------------------------------*/
9338: IF ( G_LEVEL_UNEXPECTED >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 9409: FND_MSG_PUB.Add();

9405: FND_LOG.STRING(G_LEVEL_PROCEDURE,G_MODULE_NAME||l_api_name||'.BEGIN','ZX_API_PUB: '||l_api_name||'()+');
9406: END IF;
9407: --Add unexpected errors to fnd_stack
9408: IF p_context_info_rec.application_id is null THEN
9409: FND_MSG_PUB.Add();
9410: END IF;
9411:
9412: IF G_DATA_TRANSFER_MODE = 'PLS' OR
9413: G_DATA_TRANSFER_MODE = 'WIN' THEN

Line 9419: FND_MSG_PUB.Add();

9415: since message is already in stack.*/
9416: IF G_EXTERNAL_API_CALL = 'Y' THEN
9417: G_EXTERNAL_API_CALL := 'N';
9418: ELSE
9419: FND_MSG_PUB.Add();
9420: END IF;
9421: ELSIF G_DATA_TRANSFER_MODE = 'TAB' THEN
9422: l_count:= errors_tbl.application_id.COUNT;
9423: IF G_EXTERNAL_API_CALL = 'Y' THEN

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

9421: ELSIF G_DATA_TRANSFER_MODE = 'TAB' THEN
9422: l_count:= errors_tbl.application_id.COUNT;
9423: IF G_EXTERNAL_API_CALL = 'Y' THEN
9424: LOOP
9425: l_mesg := FND_MSG_PUB.Get(FND_MSG_PUB.G_NEXT, FND_API.G_FALSE);
9426: IF l_mesg IS NULL THEN
9427: EXIT;
9428: ELSE
9429: errors_tbl.application_id(l_count+1) := p_context_info_rec.application_id;

Line 9601: FND_MSG_PUB.initialize;

9597: l_init_msg_list := p_init_msg_list;
9598: END IF;
9599:
9600: IF FND_API.to_Boolean(l_init_msg_list) THEN
9601: FND_MSG_PUB.initialize;
9602: END IF;
9603:
9604: /*-----------------------------------------+
9605: | Initialize return status to SUCCESS |

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

9652: -- ROLLBACK TO Get_Default_Tax_Reg_PVT;
9653: x_return_status := FND_API.G_RET_STS_ERROR ;
9654: DUMP_MSG;
9655: /*---------------------------------------------------------+
9656: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
9657: | in the message stack. If there is only one message in |
9658: | the stack it retrieves this message |
9659: +---------------------------------------------------------*/
9660: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

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

9656: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
9657: | in the message stack. If there is only one message in |
9658: | the stack it retrieves this message |
9659: +---------------------------------------------------------*/
9660: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
9661: p_count => x_msg_count,
9662: p_data => x_msg_data
9663: );
9664: IF ( G_LEVEL_ERROR >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 9674: FND_MSG_PUB.Add;

9670: -- ROLLBACK TO Get_Default_Tax_Reg_PVT;
9671: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
9672: DUMP_MSG;
9673: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
9674: FND_MSG_PUB.Add;
9675: /*---------------------------------------------------------+
9676: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
9677: | in the message stack. If there is only one message in |
9678: | the stack it retrieves this message |

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

9672: DUMP_MSG;
9673: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
9674: FND_MSG_PUB.Add;
9675: /*---------------------------------------------------------+
9676: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
9677: | in the message stack. If there is only one message in |
9678: | the stack it retrieves this message |
9679: +---------------------------------------------------------*/
9680: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

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

9676: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
9677: | in the message stack. If there is only one message in |
9678: | the stack it retrieves this message |
9679: +---------------------------------------------------------*/
9680: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
9681: p_count => x_msg_count,
9682: p_data => x_msg_data
9683: );
9684: IF ( G_LEVEL_ERROR >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 9693: FND_MSG_PUB.Add;

9689: -- Commented rollback as per bug 5395191
9690: -- ROLLBACK TO Get_Default_Tax_Reg_PVT;
9691: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
9692: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
9693: FND_MSG_PUB.Add;
9694: /*---------------------------------------------------------+
9695: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
9696: | in the message stack. If there is only one message in |
9697: | the stack it retrieves this message |

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

9691: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
9692: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
9693: FND_MSG_PUB.Add;
9694: /*---------------------------------------------------------+
9695: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
9696: | in the message stack. If there is only one message in |
9697: | the stack it retrieves this message |
9698: +---------------------------------------------------------*/
9699: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

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

9695: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
9696: | in the message stack. If there is only one message in |
9697: | the stack it retrieves this message |
9698: +---------------------------------------------------------*/
9699: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
9700: p_count => x_msg_count,
9701: p_data => x_msg_data
9702: );
9703: IF ( G_LEVEL_UNEXPECTED >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 9767: FND_MSG_PUB.initialize;

9763: l_init_msg_list := p_init_msg_list;
9764: END IF;
9765:
9766: IF FND_API.to_Boolean(l_init_msg_list) THEN
9767: FND_MSG_PUB.initialize;
9768: END IF;
9769:
9770: /*-----------------------------------------+
9771: | Initialize return status to SUCCESS |

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

10022: ROLLBACK TO Insert_Line_Det_Factors_PVT;
10023: x_return_status := FND_API.G_RET_STS_ERROR ;
10024: DUMP_MSG;
10025: /*---------------------------------------------------------+
10026: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
10027: | in the message stack. If there is only one message in |
10028: | the stack it retrieves this message |
10029: +---------------------------------------------------------*/
10030: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

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

10026: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
10027: | in the message stack. If there is only one message in |
10028: | the stack it retrieves this message |
10029: +---------------------------------------------------------*/
10030: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
10031: p_count => x_msg_count,
10032: p_data => x_msg_data
10033: );
10034:

Line 10044: FND_MSG_PUB.Add;

10040: ROLLBACK TO Insert_Line_Det_Factors_PVT;
10041: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
10042: DUMP_MSG;
10043: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
10044: FND_MSG_PUB.Add;
10045: /*---------------------------------------------------------+
10046: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
10047: | in the message stack. If there is only one message in |
10048: | the stack it retrieves this message |

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

10042: DUMP_MSG;
10043: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
10044: FND_MSG_PUB.Add;
10045: /*---------------------------------------------------------+
10046: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
10047: | in the message stack. If there is only one message in |
10048: | the stack it retrieves this message |
10049: +---------------------------------------------------------*/
10050: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

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

10046: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
10047: | in the message stack. If there is only one message in |
10048: | the stack it retrieves this message |
10049: +---------------------------------------------------------*/
10050: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
10051: p_count => x_msg_count,
10052: p_data => x_msg_data
10053: );
10054: IF ( G_LEVEL_ERROR >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 10067: FND_MSG_PUB.Add;

10063: ELSE
10064: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
10065: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
10066: END IF;
10067: FND_MSG_PUB.Add;
10068: /*---------------------------------------------------------+
10069: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
10070: | in the message stack. If there is only one message in |
10071: | the stack it retrieves this message |

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

10065: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
10066: END IF;
10067: FND_MSG_PUB.Add;
10068: /*---------------------------------------------------------+
10069: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
10070: | in the message stack. If there is only one message in |
10071: | the stack it retrieves this message |
10072: +---------------------------------------------------------*/
10073: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

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

10069: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
10070: | in the message stack. If there is only one message in |
10071: | the stack it retrieves this message |
10072: +---------------------------------------------------------*/
10073: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
10074: p_count => x_msg_count,
10075: p_data => x_msg_data
10076: );
10077:

Line 10139: FND_MSG_PUB.initialize;

10135: l_init_msg_list := p_init_msg_list;
10136: END IF;
10137:
10138: IF FND_API.to_Boolean(l_init_msg_list) THEN
10139: FND_MSG_PUB.initialize;
10140: END IF;
10141:
10142: /*-----------------------------------------+
10143: | Initialize return status to SUCCESS |

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

10313: ROLLBACK TO Insert_Line_Det_Factors_PVT;
10314: x_return_status := FND_API.G_RET_STS_ERROR ;
10315: DUMP_MSG;
10316: /*---------------------------------------------------------+
10317: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
10318: | in the message stack. If there is only one message in |
10319: | the stack it retrieves this message |
10320: +---------------------------------------------------------*/
10321: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

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

10317: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
10318: | in the message stack. If there is only one message in |
10319: | the stack it retrieves this message |
10320: +---------------------------------------------------------*/
10321: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
10322: p_count => x_msg_count,
10323: p_data => x_msg_data
10324: );
10325:

Line 10335: FND_MSG_PUB.Add;

10331: ROLLBACK TO Insert_Line_Det_Factors_PVT;
10332: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
10333: DUMP_MSG;
10334: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
10335: FND_MSG_PUB.Add;
10336: /*---------------------------------------------------------+
10337: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
10338: | in the message stack. If there is only one message in |
10339: | the stack it retrieves this message |

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

10333: DUMP_MSG;
10334: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
10335: FND_MSG_PUB.Add;
10336: /*---------------------------------------------------------+
10337: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
10338: | in the message stack. If there is only one message in |
10339: | the stack it retrieves this message |
10340: +---------------------------------------------------------*/
10341: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

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

10337: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
10338: | in the message stack. If there is only one message in |
10339: | the stack it retrieves this message |
10340: +---------------------------------------------------------*/
10341: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
10342: p_count => x_msg_count,
10343: p_data => x_msg_data
10344: );
10345: IF ( G_LEVEL_ERROR >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 10363: FND_MSG_PUB.Add;

10359: ELSE
10360: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
10361: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
10362: END IF;
10363: FND_MSG_PUB.Add;
10364: /*---------------------------------------------------------+
10365: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
10366: | in the message stack. If there is only one message in |
10367: | the stack it retrieves this message |

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

10361: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
10362: END IF;
10363: FND_MSG_PUB.Add;
10364: /*---------------------------------------------------------+
10365: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
10366: | in the message stack. If there is only one message in |
10367: | the stack it retrieves this message |
10368: +---------------------------------------------------------*/
10369: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

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

10365: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
10366: | in the message stack. If there is only one message in |
10367: | the stack it retrieves this message |
10368: +---------------------------------------------------------*/
10369: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
10370: p_count => x_msg_count,
10371: p_data => x_msg_data
10372: );
10373:

Line 10463: FND_MSG_PUB.initialize;

10459: l_init_msg_list := p_init_msg_list;
10460: END IF;
10461:
10462: IF FND_API.to_Boolean(l_init_msg_list) THEN
10463: FND_MSG_PUB.initialize;
10464: END IF;
10465:
10466: /*-----------------------------------------+
10467: | Initialize return status to SUCCESS |

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

12064: ROLLBACK TO Update_Det_Factors_Hdr_PVT;
12065: x_return_status := FND_API.G_RET_STS_ERROR ;
12066: DUMP_MSG;
12067: /*---------------------------------------------------------+
12068: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
12069: | in the message stack. If there is only one message in |
12070: | the stack it retrieves this message |
12071: +---------------------------------------------------------*/
12072: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

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

12068: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
12069: | in the message stack. If there is only one message in |
12070: | the stack it retrieves this message |
12071: +---------------------------------------------------------*/
12072: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
12073: p_count => x_msg_count,
12074: p_data => x_msg_data
12075: );
12076:

Line 12086: FND_MSG_PUB.Add;

12082: ROLLBACK TO Update_Det_Factors_Hdr_PVT;
12083: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
12084: DUMP_MSG;
12085: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
12086: FND_MSG_PUB.Add;
12087: /*---------------------------------------------------------+
12088: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
12089: | in the message stack. If there is only one message in |
12090: | the stack it retrieves this message |

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

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

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

12088: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
12089: | in the message stack. If there is only one message in |
12090: | the stack it retrieves this message |
12091: +---------------------------------------------------------*/
12092: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
12093: p_count => x_msg_count,
12094: p_data => x_msg_data
12095: );
12096: IF ( G_LEVEL_ERROR >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 12103: FND_MSG_PUB.Add;

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

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

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

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

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

Line 12176: FND_MSG_PUB.initialize;

12172: l_init_msg_list := p_init_msg_list;
12173: END IF;
12174:
12175: IF FND_API.to_Boolean(l_init_msg_list) THEN
12176: FND_MSG_PUB.initialize;
12177: END IF;
12178:
12179: /*-----------------------------------------+
12180: | Initialize return status to SUCCESS |

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

12393: ROLLBACK TO Update_Line_Det_Factors_PVT;
12394: x_return_status := FND_API.G_RET_STS_ERROR ;
12395: DUMP_MSG;
12396: /*---------------------------------------------------------+
12397: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
12398: | in the message stack. If there is only one message in |
12399: | the stack it retrieves this message |
12400: +---------------------------------------------------------*/
12401: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

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

12397: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
12398: | in the message stack. If there is only one message in |
12399: | the stack it retrieves this message |
12400: +---------------------------------------------------------*/
12401: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
12402: p_count => x_msg_count,
12403: p_data => x_msg_data
12404: );
12405:

Line 12415: FND_MSG_PUB.Add;

12411: ROLLBACK TO Update_Line_Det_Factors_PVT;
12412: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
12413: DUMP_MSG;
12414: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
12415: FND_MSG_PUB.Add;
12416: /*---------------------------------------------------------+
12417: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
12418: | in the message stack. If there is only one message in |
12419: | the stack it retrieves this message |

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

12413: DUMP_MSG;
12414: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
12415: FND_MSG_PUB.Add;
12416: /*---------------------------------------------------------+
12417: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
12418: | in the message stack. If there is only one message in |
12419: | the stack it retrieves this message |
12420: +---------------------------------------------------------*/
12421: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

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

12417: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
12418: | in the message stack. If there is only one message in |
12419: | the stack it retrieves this message |
12420: +---------------------------------------------------------*/
12421: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
12422: p_count => x_msg_count,
12423: p_data => x_msg_data
12424: );
12425: IF ( G_LEVEL_ERROR >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 12443: FND_MSG_PUB.Add;

12439: ELSE
12440: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
12441: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
12442: END IF;
12443: FND_MSG_PUB.Add;
12444: /*---------------------------------------------------------+
12445: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
12446: | in the message stack. If there is only one message in |
12447: | the stack it retrieves this message |

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

12441: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
12442: END IF;
12443: FND_MSG_PUB.Add;
12444: /*---------------------------------------------------------+
12445: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
12446: | in the message stack. If there is only one message in |
12447: | the stack it retrieves this message |
12448: +---------------------------------------------------------*/
12449: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

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

12445: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
12446: | in the message stack. If there is only one message in |
12447: | the stack it retrieves this message |
12448: +---------------------------------------------------------*/
12449: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
12450: p_count => x_msg_count,
12451: p_data => x_msg_data
12452: );
12453:

Line 12516: FND_MSG_PUB.initialize;

12512: l_init_msg_list := p_init_msg_list;
12513: END IF;
12514:
12515: IF FND_API.to_Boolean(l_init_msg_list) THEN
12516: FND_MSG_PUB.initialize;
12517: END IF;
12518:
12519: /*-----------------------------------------+
12520: | Initialize return status to SUCCESS |

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

12709: ROLLBACK TO Copy_Ins_Line_Det_Factors_PVT;
12710: x_return_status := FND_API.G_RET_STS_ERROR ;
12711: DUMP_MSG;
12712: /*---------------------------------------------------------+
12713: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
12714: | in the message stack. If there is only one message in |
12715: | the stack it retrieves this message |
12716: +---------------------------------------------------------*/
12717: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

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

12713: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
12714: | in the message stack. If there is only one message in |
12715: | the stack it retrieves this message |
12716: +---------------------------------------------------------*/
12717: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
12718: p_count => x_msg_count,
12719: p_data => x_msg_data
12720: );
12721:

Line 12731: FND_MSG_PUB.Add;

12727: ROLLBACK TO Copy_Ins_Line_Det_Factors_PVT;
12728: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
12729: DUMP_MSG;
12730: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
12731: FND_MSG_PUB.Add;
12732: /*---------------------------------------------------------+
12733: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
12734: | in the message stack. If there is only one message in |
12735: | the stack it retrieves this message |

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

12729: DUMP_MSG;
12730: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
12731: FND_MSG_PUB.Add;
12732: /*---------------------------------------------------------+
12733: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
12734: | in the message stack. If there is only one message in |
12735: | the stack it retrieves this message |
12736: +---------------------------------------------------------*/
12737: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

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

12733: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
12734: | in the message stack. If there is only one message in |
12735: | the stack it retrieves this message |
12736: +---------------------------------------------------------*/
12737: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
12738: p_count => x_msg_count,
12739: p_data => x_msg_data
12740: );
12741: IF ( G_LEVEL_ERROR >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 12759: FND_MSG_PUB.Add;

12755: ELSE
12756: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
12757: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
12758: END IF;
12759: FND_MSG_PUB.Add;
12760: /*---------------------------------------------------------+
12761: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
12762: | in the message stack. If there is only one message in |
12763: | the stack it retrieves this message |

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

12757: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
12758: END IF;
12759: FND_MSG_PUB.Add;
12760: /*---------------------------------------------------------+
12761: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
12762: | in the message stack. If there is only one message in |
12763: | the stack it retrieves this message |
12764: +---------------------------------------------------------*/
12765: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

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

12761: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
12762: | in the message stack. If there is only one message in |
12763: | the stack it retrieves this message |
12764: +---------------------------------------------------------*/
12765: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
12766: p_count => x_msg_count,
12767: p_data => x_msg_data
12768: );
12769:

Line 12827: FND_MSG_PUB.initialize;

12823: l_init_msg_list := p_init_msg_list;
12824: END IF;
12825:
12826: IF FND_API.to_Boolean(l_init_msg_list) THEN
12827: FND_MSG_PUB.initialize;
12828: END IF;
12829:
12830: /*-----------------------------------------+
12831: | Initialize return status to SUCCESS |

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

12870: ROLLBACK TO Is_Recoverability_Affected_PVT;
12871: x_return_status := FND_API.G_RET_STS_ERROR ;
12872: DUMP_MSG;
12873: /*---------------------------------------------------------+
12874: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
12875: | in the message stack. If there is only one message in |
12876: | the stack it retrieves this message |
12877: +---------------------------------------------------------*/
12878: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

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

12874: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
12875: | in the message stack. If there is only one message in |
12876: | the stack it retrieves this message |
12877: +---------------------------------------------------------*/
12878: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
12879: p_count => x_msg_count,
12880: p_data => x_msg_data
12881: );
12882:

Line 12892: FND_MSG_PUB.Add;

12888: ROLLBACK TO Is_Recoverability_Affected_PVT;
12889: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
12890: DUMP_MSG;
12891: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
12892: FND_MSG_PUB.Add;
12893: /*---------------------------------------------------------+
12894: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
12895: | in the message stack. If there is only one message in |
12896: | the stack it retrieves this message |

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

12890: DUMP_MSG;
12891: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
12892: FND_MSG_PUB.Add;
12893: /*---------------------------------------------------------+
12894: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
12895: | in the message stack. If there is only one message in |
12896: | the stack it retrieves this message |
12897: +---------------------------------------------------------*/
12898: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

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

12894: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
12895: | in the message stack. If there is only one message in |
12896: | the stack it retrieves this message |
12897: +---------------------------------------------------------*/
12898: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
12899: p_count => x_msg_count,
12900: p_data => x_msg_data
12901: );
12902:

Line 12911: FND_MSG_PUB.Add;

12907: WHEN OTHERS THEN
12908: ROLLBACK TO Is_Recoverability_Affected_PVT;
12909: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
12910: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
12911: FND_MSG_PUB.Add;
12912: /*---------------------------------------------------------+
12913: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
12914: | in the message stack. If there is only one message in |
12915: | the stack it retrieves this message |

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

12909: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
12910: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
12911: FND_MSG_PUB.Add;
12912: /*---------------------------------------------------------+
12913: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
12914: | in the message stack. If there is only one message in |
12915: | the stack it retrieves this message |
12916: +---------------------------------------------------------*/
12917: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

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

12913: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
12914: | in the message stack. If there is only one message in |
12915: | the stack it retrieves this message |
12916: +---------------------------------------------------------*/
12917: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
12918: p_count => x_msg_count,
12919: p_data => x_msg_data
12920: );
12921: IF ( G_LEVEL_UNEXPECTED >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 12981: FND_MSG_PUB.initialize;

12977: l_init_msg_list := p_init_msg_list;
12978: END IF;
12979:
12980: IF FND_API.to_Boolean(l_init_msg_list) THEN
12981: FND_MSG_PUB.initialize;
12982: END IF;
12983:
12984: /*-----------------------------------------+
12985: | Initialize return status to SUCCESS |

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

13086: ROLLBACK TO Del_Tax_Line_And_Dists_PVT;
13087: x_return_status := FND_API.G_RET_STS_ERROR ;
13088: DUMP_MSG;
13089: /*---------------------------------------------------------+
13090: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
13091: | in the message stack. If there is only one message in |
13092: | the stack it retrieves this message |
13093: +---------------------------------------------------------*/
13094: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

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

13090: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
13091: | in the message stack. If there is only one message in |
13092: | the stack it retrieves this message |
13093: +---------------------------------------------------------*/
13094: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
13095: p_count => x_msg_count,
13096: p_data => x_msg_data
13097: );
13098:

Line 13108: FND_MSG_PUB.Add;

13104: ROLLBACK TO Del_Tax_Line_And_Dists_PVT;
13105: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
13106: DUMP_MSG;
13107: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
13108: FND_MSG_PUB.Add;
13109: /*---------------------------------------------------------+
13110: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
13111: | in the message stack. If there is only one message in |
13112: | the stack it retrieves this message |

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

13106: DUMP_MSG;
13107: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
13108: FND_MSG_PUB.Add;
13109: /*---------------------------------------------------------+
13110: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
13111: | in the message stack. If there is only one message in |
13112: | the stack it retrieves this message |
13113: +---------------------------------------------------------*/
13114: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

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

13110: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
13111: | in the message stack. If there is only one message in |
13112: | the stack it retrieves this message |
13113: +---------------------------------------------------------*/
13114: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
13115: p_count => x_msg_count,
13116: p_data => x_msg_data
13117: );
13118:

Line 13127: FND_MSG_PUB.Add;

13123: WHEN OTHERS THEN
13124: ROLLBACK TO Del_Tax_Line_And_Dists_PVT;
13125: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
13126: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
13127: FND_MSG_PUB.Add;
13128: /*---------------------------------------------------------+
13129: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
13130: | in the message stack. If there is only one message in |
13131: | the stack it retrieves this message |

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

13125: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
13126: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
13127: FND_MSG_PUB.Add;
13128: /*---------------------------------------------------------+
13129: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
13130: | in the message stack. If there is only one message in |
13131: | the stack it retrieves this message |
13132: +---------------------------------------------------------*/
13133: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

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

13129: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
13130: | in the message stack. If there is only one message in |
13131: | the stack it retrieves this message |
13132: +---------------------------------------------------------*/
13133: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
13134: p_count => x_msg_count,
13135: p_data => x_msg_data
13136: );
13137: IF ( G_LEVEL_UNEXPECTED >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 13193: FND_MSG_PUB.initialize;

13189: l_init_msg_list := p_init_msg_list;
13190: END IF;
13191:
13192: IF FND_API.to_Boolean(l_init_msg_list) THEN
13193: FND_MSG_PUB.initialize;
13194: END IF;
13195:
13196: /*-----------------------------------------+
13197: | Initialize return status to SUCCESS |

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

13243: ROLLBACK TO Del_Tax_Distributions_PVT;
13244: x_return_status := FND_API.G_RET_STS_ERROR ;
13245: DUMP_MSG;
13246: /*---------------------------------------------------------+
13247: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
13248: | in the message stack. If there is only one message in |
13249: | the stack it retrieves this message |
13250: +---------------------------------------------------------*/
13251: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

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

13247: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
13248: | in the message stack. If there is only one message in |
13249: | the stack it retrieves this message |
13250: +---------------------------------------------------------*/
13251: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
13252: p_count => x_msg_count,
13253: p_data => x_msg_data
13254: );
13255:

Line 13265: FND_MSG_PUB.Add;

13261: ROLLBACK TO Del_Tax_Distributions_PVT;
13262: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
13263: DUMP_MSG;
13264: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
13265: FND_MSG_PUB.Add;
13266: /*---------------------------------------------------------+
13267: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
13268: | in the message stack. If there is only one message in |
13269: | the stack it retrieves this message |

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

13263: DUMP_MSG;
13264: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
13265: FND_MSG_PUB.Add;
13266: /*---------------------------------------------------------+
13267: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
13268: | in the message stack. If there is only one message in |
13269: | the stack it retrieves this message |
13270: +---------------------------------------------------------*/
13271: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

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

13267: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
13268: | in the message stack. If there is only one message in |
13269: | the stack it retrieves this message |
13270: +---------------------------------------------------------*/
13271: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
13272: p_count => x_msg_count,
13273: p_data => x_msg_data
13274: );
13275:

Line 13284: FND_MSG_PUB.Add;

13280: WHEN OTHERS THEN
13281: ROLLBACK TO Del_Tax_Distributions_PVT;
13282: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
13283: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
13284: FND_MSG_PUB.Add;
13285: /*---------------------------------------------------------+
13286: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
13287: | in the message stack. If there is only one message in |
13288: | the stack it retrieves this message |

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

13282: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
13283: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
13284: FND_MSG_PUB.Add;
13285: /*---------------------------------------------------------+
13286: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
13287: | in the message stack. If there is only one message in |
13288: | the stack it retrieves this message |
13289: +---------------------------------------------------------*/
13290: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

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

13286: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
13287: | in the message stack. If there is only one message in |
13288: | the stack it retrieves this message |
13289: +---------------------------------------------------------*/
13290: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
13291: p_count => x_msg_count,
13292: p_data => x_msg_data
13293: );
13294: IF ( G_LEVEL_UNEXPECTED >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 13418: FND_MSG_PUB.initialize;

13414: l_init_msg_list := p_init_msg_list;
13415: END IF;
13416:
13417: IF FND_API.to_Boolean(l_init_msg_list) THEN
13418: FND_MSG_PUB.initialize;
13419: END IF;
13420:
13421: /*-----------------------------------------+
13422: | Initialize return status to SUCCESS |

Line 13597: FND_MSG_PUB.Add;

13593: IF headers_doc%ISOPEN THEN CLOSE headers_doc; END IF;
13594: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
13595: DUMP_MSG;
13596: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
13597: FND_MSG_PUB.Add;
13598: /*---------------------------------------------------------+
13599: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
13600: | in the message stack. If there is only one message in |
13601: | the stack it retrieves this message |

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

13595: DUMP_MSG;
13596: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
13597: FND_MSG_PUB.Add;
13598: /*---------------------------------------------------------+
13599: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
13600: | in the message stack. If there is only one message in |
13601: | the stack it retrieves this message |
13602: +---------------------------------------------------------*/
13603: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

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

13599: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
13600: | in the message stack. If there is only one message in |
13601: | the stack it retrieves this message |
13602: +---------------------------------------------------------*/
13603: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
13604: p_count => x_msg_count,
13605: p_data => x_msg_data
13606: );
13607: IF ( G_LEVEL_ERROR >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 13617: FND_MSG_PUB.Add;

13613: --Close all open cursors
13614: IF headers_doc%ISOPEN THEN CLOSE headers_doc; END IF;
13615: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
13616: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
13617: FND_MSG_PUB.Add;
13618: /*---------------------------------------------------------+
13619: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
13620: | in the message stack. If there is only one message in |
13621: | the stack it retrieves this message |

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

13615: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
13616: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
13617: FND_MSG_PUB.Add;
13618: /*---------------------------------------------------------+
13619: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
13620: | in the message stack. If there is only one message in |
13621: | the stack it retrieves this message |
13622: +---------------------------------------------------------*/
13623: IF ( G_LEVEL_UNEXPECTED >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 13685: FND_MSG_PUB.initialize;

13681: l_init_msg_list := p_init_msg_list;
13682: END IF;
13683:
13684: IF FND_API.to_Boolean(l_init_msg_list) THEN
13685: FND_MSG_PUB.initialize;
13686: END IF;
13687:
13688: /*-----------------------------------------+
13689: | Initialize return status to SUCCESS |

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

13745: ROLLBACK TO Redefault_Intended_Use_PVT;
13746: x_return_status := FND_API.G_RET_STS_ERROR ;
13747: DUMP_MSG;
13748: /*---------------------------------------------------------+
13749: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
13750: | in the message stack. If there is only one message in |
13751: | the stack it retrieves this message |
13752: +---------------------------------------------------------*/
13753: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

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

13749: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
13750: | in the message stack. If there is only one message in |
13751: | the stack it retrieves this message |
13752: +---------------------------------------------------------*/
13753: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
13754: p_count => x_msg_count,
13755: p_data => x_msg_data
13756: );
13757: IF ( G_LEVEL_ERROR >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 13766: FND_MSG_PUB.Add;

13762: ROLLBACK TO Redefault_Intended_Use_PVT;
13763: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
13764: DUMP_MSG;
13765: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
13766: FND_MSG_PUB.Add;
13767: /*---------------------------------------------------------+
13768: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
13769: | in the message stack. If there is only one message in |
13770: | the stack it retrieves this message |

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

13764: DUMP_MSG;
13765: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
13766: FND_MSG_PUB.Add;
13767: /*---------------------------------------------------------+
13768: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
13769: | in the message stack. If there is only one message in |
13770: | the stack it retrieves this message |
13771: +---------------------------------------------------------*/
13772: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

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

13768: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
13769: | in the message stack. If there is only one message in |
13770: | the stack it retrieves this message |
13771: +---------------------------------------------------------*/
13772: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
13773: p_count => x_msg_count,
13774: p_data => x_msg_data
13775: );
13776: IF ( G_LEVEL_ERROR >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 13784: FND_MSG_PUB.Add;

13780: WHEN OTHERS THEN
13781: ROLLBACK TO Redefault_Intended_Use_PVT;
13782: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
13783: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
13784: FND_MSG_PUB.Add;
13785: /*---------------------------------------------------------+
13786: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
13787: | in the message stack. If there is only one message in |
13788: | the stack it retrieves this message |

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

13782: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
13783: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
13784: FND_MSG_PUB.Add;
13785: /*---------------------------------------------------------+
13786: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
13787: | in the message stack. If there is only one message in |
13788: | the stack it retrieves this message |
13789: +---------------------------------------------------------*/
13790: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

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

13786: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
13787: | in the message stack. If there is only one message in |
13788: | the stack it retrieves this message |
13789: +---------------------------------------------------------*/
13790: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
13791: p_count => x_msg_count,
13792: p_data => x_msg_data
13793: );
13794: IF ( G_LEVEL_UNEXPECTED >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 13856: FND_MSG_PUB.initialize;

13852: l_init_msg_list := p_init_msg_list;
13853: END IF;
13854:
13855: IF FND_API.to_Boolean(l_init_msg_list) THEN
13856: FND_MSG_PUB.initialize;
13857: END IF;
13858:
13859: /*-----------------------------------------+
13860: | Initialize return status to SUCCESS |

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

13915: ROLLBACK TO Redef_Prod_Fisc_Class_Code_PVT;
13916: x_return_status := FND_API.G_RET_STS_ERROR ;
13917: DUMP_MSG;
13918: /*---------------------------------------------------------+
13919: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
13920: | in the message stack. If there is only one message in |
13921: | the stack it retrieves this message |
13922: +---------------------------------------------------------*/
13923: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

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

13919: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
13920: | in the message stack. If there is only one message in |
13921: | the stack it retrieves this message |
13922: +---------------------------------------------------------*/
13923: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
13924: p_count => x_msg_count,
13925: p_data => x_msg_data
13926: );
13927:

Line 13937: FND_MSG_PUB.Add;

13933: ROLLBACK TO Redef_Prod_Fisc_Class_Code_PVT;
13934: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
13935: DUMP_MSG;
13936: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
13937: FND_MSG_PUB.Add;
13938: /*---------------------------------------------------------+
13939: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
13940: | in the message stack. If there is only one message in |
13941: | the stack it retrieves this message |

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

13935: DUMP_MSG;
13936: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
13937: FND_MSG_PUB.Add;
13938: /*---------------------------------------------------------+
13939: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
13940: | in the message stack. If there is only one message in |
13941: | the stack it retrieves this message |
13942: +---------------------------------------------------------*/
13943: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

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

13939: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
13940: | in the message stack. If there is only one message in |
13941: | the stack it retrieves this message |
13942: +---------------------------------------------------------*/
13943: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
13944: p_count => x_msg_count,
13945: p_data => x_msg_data
13946: );
13947: IF ( G_LEVEL_ERROR >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 13955: FND_MSG_PUB.Add;

13951: WHEN OTHERS THEN
13952: ROLLBACK TO Redef_Prod_Fisc_Class_Code_PVT;
13953: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
13954: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
13955: FND_MSG_PUB.Add;
13956: /*---------------------------------------------------------+
13957: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
13958: | in the message stack. If there is only one message in |
13959: | the stack it retrieves this message |

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

13953: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
13954: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
13955: FND_MSG_PUB.Add;
13956: /*---------------------------------------------------------+
13957: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
13958: | in the message stack. If there is only one message in |
13959: | the stack it retrieves this message |
13960: +---------------------------------------------------------*/
13961: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

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

13957: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
13958: | in the message stack. If there is only one message in |
13959: | the stack it retrieves this message |
13960: +---------------------------------------------------------*/
13961: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
13962: p_count => x_msg_count,
13963: p_data => x_msg_data
13964: );
13965: IF ( G_LEVEL_UNEXPECTED >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 14031: FND_MSG_PUB.initialize;

14027: l_init_msg_list := p_init_msg_list;
14028: END IF;
14029:
14030: IF FND_API.to_Boolean(l_init_msg_list) THEN
14031: FND_MSG_PUB.initialize;
14032: END IF;
14033:
14034: /*-----------------------------------------+
14035: | Initialize return status to SUCCESS |

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

14097: ROLLBACK TO Redefault_Assessable_Value_PVT;
14098: x_return_status := FND_API.G_RET_STS_ERROR ;
14099: DUMP_MSG;
14100: /*---------------------------------------------------------+
14101: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
14102: | in the message stack. If there is only one message in |
14103: | the stack it retrieves this message |
14104: +---------------------------------------------------------*/
14105: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

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

14101: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
14102: | in the message stack. If there is only one message in |
14103: | the stack it retrieves this message |
14104: +---------------------------------------------------------*/
14105: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
14106: p_count => x_msg_count,
14107: p_data => x_msg_data
14108: );
14109: IF ( G_LEVEL_ERROR >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 14118: FND_MSG_PUB.Add;

14114: ROLLBACK TO Redefault_Assessable_Value_PVT;
14115: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
14116: DUMP_MSG;
14117: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
14118: FND_MSG_PUB.Add;
14119: /*---------------------------------------------------------+
14120: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
14121: | in the message stack. If there is only one message in |
14122: | the stack it retrieves this message |

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

14116: DUMP_MSG;
14117: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
14118: FND_MSG_PUB.Add;
14119: /*---------------------------------------------------------+
14120: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
14121: | in the message stack. If there is only one message in |
14122: | the stack it retrieves this message |
14123: +---------------------------------------------------------*/
14124: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

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

14120: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
14121: | in the message stack. If there is only one message in |
14122: | the stack it retrieves this message |
14123: +---------------------------------------------------------*/
14124: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
14125: p_count => x_msg_count,
14126: p_data => x_msg_data
14127: );
14128: IF ( G_LEVEL_ERROR >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 14136: FND_MSG_PUB.Add;

14132: WHEN OTHERS THEN
14133: ROLLBACK TO Redefault_Assessable_Value_PVT;
14134: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
14135: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
14136: FND_MSG_PUB.Add;
14137: /*---------------------------------------------------------+
14138: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
14139: | in the message stack. If there is only one message in |
14140: | the stack it retrieves this message |

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

14134: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
14135: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
14136: FND_MSG_PUB.Add;
14137: /*---------------------------------------------------------+
14138: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
14139: | in the message stack. If there is only one message in |
14140: | the stack it retrieves this message |
14141: +---------------------------------------------------------*/
14142: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

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

14138: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
14139: | in the message stack. If there is only one message in |
14140: | the stack it retrieves this message |
14141: +---------------------------------------------------------*/
14142: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
14143: p_count => x_msg_count,
14144: p_data => x_msg_data
14145: );
14146: IF ( G_LEVEL_UNEXPECTED >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 14207: FND_MSG_PUB.initialize;

14203: l_init_msg_list := p_init_msg_list;
14204: END IF;
14205:
14206: IF FND_API.to_Boolean(l_init_msg_list) THEN
14207: FND_MSG_PUB.initialize;
14208: END IF;
14209:
14210: /*-----------------------------------------+
14211: | Initialize return status to SUCCESS |

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

14268: ROLLBACK TO Redefault_Assessable_Value_PVT;
14269: x_return_status := FND_API.G_RET_STS_ERROR ;
14270: DUMP_MSG;
14271: /*---------------------------------------------------------+
14272: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
14273: | in the message stack. If there is only one message in |
14274: | the stack it retrieves this message |
14275: +---------------------------------------------------------*/
14276: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

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

14272: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
14273: | in the message stack. If there is only one message in |
14274: | the stack it retrieves this message |
14275: +---------------------------------------------------------*/
14276: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
14277: p_count => x_msg_count,
14278: p_data => x_msg_data
14279: );
14280: IF ( G_LEVEL_ERROR >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 14289: FND_MSG_PUB.Add;

14285: ROLLBACK TO Redefault_Assessable_Value_PVT;
14286: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
14287: DUMP_MSG;
14288: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
14289: FND_MSG_PUB.Add;
14290: /*---------------------------------------------------------+
14291: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
14292: | in the message stack. If there is only one message in |
14293: | the stack it retrieves this message |

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

14287: DUMP_MSG;
14288: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
14289: FND_MSG_PUB.Add;
14290: /*---------------------------------------------------------+
14291: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
14292: | in the message stack. If there is only one message in |
14293: | the stack it retrieves this message |
14294: +---------------------------------------------------------*/
14295: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

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

14291: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
14292: | in the message stack. If there is only one message in |
14293: | the stack it retrieves this message |
14294: +---------------------------------------------------------*/
14295: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
14296: p_count => x_msg_count,
14297: p_data => x_msg_data
14298: );
14299: IF ( G_LEVEL_ERROR >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 14307: FND_MSG_PUB.Add;

14303: WHEN OTHERS THEN
14304: ROLLBACK TO Redefault_Assessable_Value_PVT;
14305: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
14306: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
14307: FND_MSG_PUB.Add;
14308: /*---------------------------------------------------------+
14309: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
14310: | in the message stack. If there is only one message in |
14311: | the stack it retrieves this message |

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

14305: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
14306: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
14307: FND_MSG_PUB.Add;
14308: /*---------------------------------------------------------+
14309: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
14310: | in the message stack. If there is only one message in |
14311: | the stack it retrieves this message |
14312: +---------------------------------------------------------*/
14313: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

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

14309: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
14310: | in the message stack. If there is only one message in |
14311: | the stack it retrieves this message |
14312: +---------------------------------------------------------*/
14313: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
14314: p_count => x_msg_count,
14315: p_data => x_msg_data
14316: );
14317: IF ( G_LEVEL_UNEXPECTED >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 14371: FND_MSG_PUB.initialize;

14367: l_init_msg_list := p_init_msg_list;
14368: END IF;
14369:
14370: IF FND_API.to_Boolean(l_init_msg_list) THEN
14371: FND_MSG_PUB.initialize;
14372: END IF;
14373:
14374: /*-----------------------------------------+
14375: | Initialize return status to SUCCESS |

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

14463: ROLLBACK TO Redef_Tax_Class_Code_PVT;
14464: x_return_status := FND_API.G_RET_STS_ERROR ;
14465: DUMP_MSG;
14466: /*---------------------------------------------------------+
14467: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
14468: | in the message stack. If there is only one message in |
14469: | the stack it retrieves this message |
14470: +---------------------------------------------------------*/
14471: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

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

14467: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
14468: | in the message stack. If there is only one message in |
14469: | the stack it retrieves this message |
14470: +---------------------------------------------------------*/
14471: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
14472: p_count => x_msg_count,
14473: p_data => x_msg_data
14474: );
14475: IF ( G_LEVEL_ERROR >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 14484: FND_MSG_PUB.Add;

14480: ROLLBACK TO Redef_Tax_Class_Code_PVT;
14481: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
14482: DUMP_MSG;
14483: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
14484: FND_MSG_PUB.Add;
14485: /*---------------------------------------------------------+
14486: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
14487: | in the message stack. If there is only one message in |
14488: | the stack it retrieves this message |

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

14482: DUMP_MSG;
14483: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
14484: FND_MSG_PUB.Add;
14485: /*---------------------------------------------------------+
14486: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
14487: | in the message stack. If there is only one message in |
14488: | the stack it retrieves this message |
14489: +---------------------------------------------------------*/
14490: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

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

14486: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
14487: | in the message stack. If there is only one message in |
14488: | the stack it retrieves this message |
14489: +---------------------------------------------------------*/
14490: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
14491: p_count => x_msg_count,
14492: p_data => x_msg_data
14493: );
14494: IF ( G_LEVEL_ERROR >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 14502: FND_MSG_PUB.Add;

14498: WHEN OTHERS THEN
14499: ROLLBACK TO Redef_Tax_Class_Code_PVT;
14500: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
14501: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
14502: FND_MSG_PUB.Add;
14503: /*---------------------------------------------------------+
14504: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
14505: | in the message stack. If there is only one message in |
14506: | the stack it retrieves this message |

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

14500: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
14501: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
14502: FND_MSG_PUB.Add;
14503: /*---------------------------------------------------------+
14504: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
14505: | in the message stack. If there is only one message in |
14506: | the stack it retrieves this message |
14507: +---------------------------------------------------------*/
14508: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

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

14504: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
14505: | in the message stack. If there is only one message in |
14506: | the stack it retrieves this message |
14507: +---------------------------------------------------------*/
14508: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
14509: p_count => x_msg_count,
14510: p_data => x_msg_data
14511: );
14512: IF ( G_LEVEL_UNEXPECTED >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 14573: FND_MSG_PUB.initialize;

14569: l_init_msg_list := p_init_msg_list;
14570: END IF;
14571:
14572: IF FND_API.to_Boolean(l_init_msg_list) THEN
14573: FND_MSG_PUB.initialize;
14574: END IF;
14575:
14576: /*-----------------------------------------+
14577: | Initialize return status to SUCCESS |

Line 14733: FND_MSG_PUB.Add;

14729: ROLLBACK TO Purge_Tax_Repository_PVT;
14730: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
14731: DUMP_MSG;
14732: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
14733: FND_MSG_PUB.Add;
14734: /*---------------------------------------------------------+
14735: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
14736: | in the message stack. If there is only one message in |
14737: | the stack it retrieves this message |

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

14731: DUMP_MSG;
14732: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
14733: FND_MSG_PUB.Add;
14734: /*---------------------------------------------------------+
14735: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
14736: | in the message stack. If there is only one message in |
14737: | the stack it retrieves this message |
14738: +---------------------------------------------------------*/
14739: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

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

14735: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
14736: | in the message stack. If there is only one message in |
14737: | the stack it retrieves this message |
14738: +---------------------------------------------------------*/
14739: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
14740: p_count => x_msg_count,
14741: p_data => x_msg_data
14742: );
14743: IF ( G_LEVEL_ERROR >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 14751: FND_MSG_PUB.Add;

14747: WHEN OTHERS THEN
14748: ROLLBACK TO Purge_Tax_Repository_PVT;
14749: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
14750: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
14751: FND_MSG_PUB.Add;
14752: /*---------------------------------------------------------+
14753: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
14754: | in the message stack. If there is only one message in |
14755: | the stack it retrieves this message |

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

14749: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
14750: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
14751: FND_MSG_PUB.Add;
14752: /*---------------------------------------------------------+
14753: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
14754: | in the message stack. If there is only one message in |
14755: | the stack it retrieves this message |
14756: +---------------------------------------------------------*/
14757: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

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

14753: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
14754: | in the message stack. If there is only one message in |
14755: | the stack it retrieves this message |
14756: +---------------------------------------------------------*/
14757: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
14758: p_count => x_msg_count,
14759: p_data => x_msg_data
14760: );
14761: IF ( G_LEVEL_UNEXPECTED >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 14819: FND_MSG_PUB.initialize;

14815: l_init_msg_list := p_init_msg_list;
14816: END IF;
14817:
14818: IF FND_API.to_Boolean(l_init_msg_list) THEN
14819: FND_MSG_PUB.initialize;
14820: END IF;
14821:
14822: /*-----------------------------------------+
14823: | Initialize return status to SUCCESS |

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

14876: ROLLBACK TO GET_LE_FROM_TAX_REGISTRATN_PVT;
14877: x_return_status := FND_API.G_RET_STS_ERROR ;
14878: DUMP_MSG;
14879: /*---------------------------------------------------------+
14880: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
14881: | in the message stack. If there is only one message in |
14882: | the stack it retrieves this message |
14883: +---------------------------------------------------------*/
14884: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

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

14880: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
14881: | in the message stack. If there is only one message in |
14882: | the stack it retrieves this message |
14883: +---------------------------------------------------------*/
14884: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
14885: p_count => x_msg_count,
14886: p_data => x_msg_data
14887: );
14888: IF ( G_LEVEL_ERROR >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 14897: FND_MSG_PUB.Add;

14893: ROLLBACK TO GET_LE_FROM_TAX_REGISTRATN_PVT;
14894: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
14895: DUMP_MSG;
14896: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
14897: FND_MSG_PUB.Add;
14898: /*---------------------------------------------------------+
14899: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
14900: | in the message stack. If there is only one message in |
14901: | the stack it retrieves this message |

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

14895: DUMP_MSG;
14896: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
14897: FND_MSG_PUB.Add;
14898: /*---------------------------------------------------------+
14899: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
14900: | in the message stack. If there is only one message in |
14901: | the stack it retrieves this message |
14902: +---------------------------------------------------------*/
14903: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

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

14899: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
14900: | in the message stack. If there is only one message in |
14901: | the stack it retrieves this message |
14902: +---------------------------------------------------------*/
14903: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
14904: p_count => x_msg_count,
14905: p_data => x_msg_data
14906: );
14907: IF ( G_LEVEL_ERROR >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 14915: FND_MSG_PUB.Add;

14911: WHEN OTHERS THEN
14912: ROLLBACK TO GET_LE_FROM_TAX_REGISTRATN_PVT;
14913: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
14914: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
14915: FND_MSG_PUB.Add;
14916: /*---------------------------------------------------------+
14917: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
14918: | in the message stack. If there is only one message in |
14919: | the stack it retrieves this message |

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

14913: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
14914: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
14915: FND_MSG_PUB.Add;
14916: /*---------------------------------------------------------+
14917: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
14918: | in the message stack. If there is only one message in |
14919: | the stack it retrieves this message |
14920: +---------------------------------------------------------*/
14921: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

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

14917: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
14918: | in the message stack. If there is only one message in |
14919: | the stack it retrieves this message |
14920: +---------------------------------------------------------*/
14921: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
14922: p_count => x_msg_count,
14923: p_data => x_msg_data
14924: );
14925: IF ( G_LEVEL_UNEXPECTED >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 14980: FND_MSG_PUB.initialize;

14976: l_init_msg_list := p_init_msg_list;
14977: END IF;
14978:
14979: IF FND_API.to_Boolean(l_init_msg_list) THEN
14980: FND_MSG_PUB.initialize;
14981: END IF;
14982:
14983: /*-----------------------------------------+
14984: | Initialize return status to SUCCESS |

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

15023: ROLLBACK TO update_posting_flag_PVT;
15024: x_return_status := FND_API.G_RET_STS_ERROR ;
15025: DUMP_MSG;
15026: /*---------------------------------------------------------+
15027: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
15028: | in the message stack. If there is only one message in |
15029: | the stack it retrieves this message |
15030: +---------------------------------------------------------*/
15031: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

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

15027: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
15028: | in the message stack. If there is only one message in |
15029: | the stack it retrieves this message |
15030: +---------------------------------------------------------*/
15031: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
15032: p_count => x_msg_count,
15033: p_data => x_msg_data
15034: );
15035:

Line 15045: FND_MSG_PUB.Add;

15041: ROLLBACK TO update_posting_flag_PVT;
15042: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
15043: DUMP_MSG;
15044: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
15045: FND_MSG_PUB.Add;
15046: /*---------------------------------------------------------+
15047: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
15048: | in the message stack. If there is only one message in |
15049: | the stack it retrieves this message |

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

15043: DUMP_MSG;
15044: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
15045: FND_MSG_PUB.Add;
15046: /*---------------------------------------------------------+
15047: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
15048: | in the message stack. If there is only one message in |
15049: | the stack it retrieves this message |
15050: +---------------------------------------------------------*/
15051: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

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

15047: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
15048: | in the message stack. If there is only one message in |
15049: | the stack it retrieves this message |
15050: +---------------------------------------------------------*/
15051: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
15052: p_count => x_msg_count,
15053: p_data => x_msg_data
15054: );
15055:

Line 15064: FND_MSG_PUB.Add;

15060: WHEN OTHERS THEN
15061: ROLLBACK TO update_posting_flag_PVT;
15062: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
15063: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
15064: FND_MSG_PUB.Add;
15065: /*---------------------------------------------------------+
15066: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
15067: | in the message stack. If there is only one message in |
15068: | the stack it retrieves this message |

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

15062: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
15063: FND_MESSAGE.SET_NAME ('ZX','ZX_UNEXPECTED_ERROR');
15064: FND_MSG_PUB.Add;
15065: /*---------------------------------------------------------+
15066: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
15067: | in the message stack. If there is only one message in |
15068: | the stack it retrieves this message |
15069: +---------------------------------------------------------*/
15070: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,

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

15066: | FND_MSG_PUB.Count_And_Get used to get the count of mesg.|
15067: | in the message stack. If there is only one message in |
15068: | the stack it retrieves this message |
15069: +---------------------------------------------------------*/
15070: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
15071: p_count => x_msg_count,
15072: p_data => x_msg_data
15073: );
15074: IF ( G_LEVEL_UNEXPECTED >= G_CURRENT_RUNTIME_LEVEL) THEN

Line 15125: FND_MSG_PUB.initialize;

15121: l_init_msg_list := p_init_msg_list;
15122: END IF;
15123:
15124: IF FND_API.to_Boolean(l_init_msg_list) THEN
15125: FND_MSG_PUB.initialize;
15126: END IF;
15127:
15128: /*----------------------------------------+
15129: | Initialize return status to SUCCESS |

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

15180: WHEN FND_API.G_EXC_ERROR THEN
15181: ROLLBACK TO unapply_applied_cm_PVT;
15182: x_return_status := FND_API.G_RET_STS_ERROR ;
15183: DUMP_MSG;
15184: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
15185: p_count => x_msg_count,
15186: p_data => x_msg_data
15187: );
15188: IF ( G_LEVEL_ERROR >= G_CURRENT_RUNTIME_LEVEL) THEN

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

15191: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
15192: ROLLBACK TO unapply_applied_cm_PVT;
15193: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
15194: DUMP_MSG;
15195: FND_MSG_PUB.Count_And_Get(p_encoded => FND_API.G_FALSE,
15196: p_count => x_msg_count,
15197: p_data => x_msg_data
15198: );
15199: IF ( G_LEVEL_ERROR >= G_CURRENT_RUNTIME_LEVEL) THEN