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.PA_TASK_PUB1 dependencies on PA_TASK_PUB1

Line 1: PACKAGE BODY PA_TASK_PUB1 AS

1: PACKAGE BODY PA_TASK_PUB1 AS
2: /* $Header: PATSK1PB.pls 120.23.12010000.4 2009/02/13 11:39:28 amehrotr ship $ */
3:
4: G_PKG_NAME CONSTANT VARCHAR2(30) := 'PA_TASK_PUB1';
5:

Line 4: G_PKG_NAME CONSTANT VARCHAR2(30) := 'PA_TASK_PUB1';

1: PACKAGE BODY PA_TASK_PUB1 AS
2: /* $Header: PATSK1PB.pls 120.23.12010000.4 2009/02/13 11:39:28 amehrotr ship $ */
3:
4: G_PKG_NAME CONSTANT VARCHAR2(30) := 'PA_TASK_PUB1';
5:
6:
7: -- API name : Create_Task
8: -- Type : Public procedure

Line 216: pa_debug.init_err_stack ('PA_TASK_PUB1.CREATE_TASK');

212:
213: -- end hyau Bug 2852753
214:
215: BEGIN
216: pa_debug.init_err_stack ('PA_TASK_PUB1.CREATE_TASK');
217:
218: IF (p_debug_mode = 'Y') THEN
219: pa_debug.debug('PA_TASK_PUB1.CREATE_TASK begin');
220: END IF;

Line 219: pa_debug.debug('PA_TASK_PUB1.CREATE_TASK begin');

215: BEGIN
216: pa_debug.init_err_stack ('PA_TASK_PUB1.CREATE_TASK');
217:
218: IF (p_debug_mode = 'Y') THEN
219: pa_debug.debug('PA_TASK_PUB1.CREATE_TASK begin');
220: END IF;
221:
222: IF (p_commit = FND_API.G_TRUE) THEN
223: savepoint create_Task;

Line 606: pa_debug.debug('PA_TASK_PUB1.CREATE_TASK END');

602: COMMIT;
603: END IF;
604:
605: IF (p_debug_mode = 'Y') THEN
606: pa_debug.debug('PA_TASK_PUB1.CREATE_TASK END');
607: END IF;
608: EXCEPTION
609: when FND_API.G_EXC_ERROR then
610: if p_commit = FND_API.G_TRUE then

Line 619: fnd_msg_pub.add_exc_msg(p_pkg_name => 'PA_TASK_PUB1',

615: if p_commit = FND_API.G_TRUE then
616: rollback to create_task;
617: end if;
618: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
619: fnd_msg_pub.add_exc_msg(p_pkg_name => 'PA_TASK_PUB1',
620: p_procedure_name => 'CREATE_TASK',
621: p_error_text => SUBSTRB(SQLERRM,1,240));
622: when OTHERS then
623: if p_commit = FND_API.G_TRUE then

Line 627: fnd_msg_pub.add_exc_msg(p_pkg_name => 'PA_TASK_PUB1',

623: if p_commit = FND_API.G_TRUE then
624: rollback to create_task;
625: end if;
626: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
627: fnd_msg_pub.add_exc_msg(p_pkg_name => 'PA_TASK_PUB1',
628: p_procedure_name => 'CREATE_TASK',
629: p_error_text => SUBSTRB(SQLERRM,1,240));
630: raise;
631: END Create_Task;

Line 890: pa_debug.init_err_stack ('PA_TASK_PUB1.UPDATE_TASK');

886: BEGIN
887:
888: --dbms_output.put_line( 'Entered ' );
889:
890: pa_debug.init_err_stack ('PA_TASK_PUB1.UPDATE_TASK');
891:
892: IF (p_debug_mode = 'Y') THEN
893: pa_debug.debug('PA_TASK_PUB1.UPDATE_TASK begin');
894: END IF;

Line 893: pa_debug.debug('PA_TASK_PUB1.UPDATE_TASK begin');

889:
890: pa_debug.init_err_stack ('PA_TASK_PUB1.UPDATE_TASK');
891:
892: IF (p_debug_mode = 'Y') THEN
893: pa_debug.debug('PA_TASK_PUB1.UPDATE_TASK begin');
894: END IF;
895:
896: IF (p_commit = FND_API.G_TRUE) THEN
897: savepoint update_Task;

Line 1497: pa_debug.debug('PA_TASK_PUB1.UPDATE_TASK END');

1493: COMMIT;
1494: END IF;
1495:
1496: IF (p_debug_mode = 'Y') THEN
1497: pa_debug.debug('PA_TASK_PUB1.UPDATE_TASK END');
1498: END IF;
1499: EXCEPTION
1500: when FND_API.G_EXC_ERROR then
1501: if p_commit = FND_API.G_TRUE then

Line 1510: fnd_msg_pub.add_exc_msg(p_pkg_name => 'PA_TASK_PUB1',

1506: if p_commit = FND_API.G_TRUE then
1507: rollback to update_task;
1508: end if;
1509: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
1510: fnd_msg_pub.add_exc_msg(p_pkg_name => 'PA_TASK_PUB1',
1511: p_procedure_name => 'UPDATE_TASK',
1512: p_error_text => SUBSTRB(SQLERRM,1,240));
1513: when OTHERS then
1514: if p_commit = FND_API.G_TRUE then

Line 1518: fnd_msg_pub.add_exc_msg(p_pkg_name => 'PA_TASK_PUB1',

1514: if p_commit = FND_API.G_TRUE then
1515: rollback to update_task;
1516: end if;
1517: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
1518: fnd_msg_pub.add_exc_msg(p_pkg_name => 'PA_TASK_PUB1',
1519: p_procedure_name => 'UPDATE_TASK',
1520: p_error_text => SUBSTRB(SQLERRM,1,240));
1521: raise;
1522:

Line 1621: pa_debug.init_err_stack ('PA_TASK_PUB1.CREATE_TASK_VERSION');

1617: l_carrying_out_org_id NUMBER;
1618: l_task_manager_id NUMBER;
1619: BEGIN
1620:
1621: pa_debug.init_err_stack ('PA_TASK_PUB1.CREATE_TASK_VERSION');
1622:
1623: IF (p_debug_mode = 'Y') THEN
1624: pa_debug.debug('PA_TASK_PUB1.CREATE_TASK_VERSION begin');
1625: END IF;

Line 1624: pa_debug.debug('PA_TASK_PUB1.CREATE_TASK_VERSION begin');

1620:
1621: pa_debug.init_err_stack ('PA_TASK_PUB1.CREATE_TASK_VERSION');
1622:
1623: IF (p_debug_mode = 'Y') THEN
1624: pa_debug.debug('PA_TASK_PUB1.CREATE_TASK_VERSION begin');
1625: END IF;
1626:
1627: IF (p_commit = FND_API.G_TRUE) THEN
1628: savepoint create_Task_version;

Line 1724: fnd_msg_pub.add_exc_msg(p_pkg_name => 'PA_TASK_PUB1',

1720: if p_commit = FND_API.G_TRUE then
1721: rollback to create_task_version;
1722: end if;
1723: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
1724: fnd_msg_pub.add_exc_msg(p_pkg_name => 'PA_TASK_PUB1',
1725: p_procedure_name => 'CREATE_TASK_VERSION',
1726: p_error_text => SUBSTRB(SQLERRM,1,240));
1727: when OTHERS then
1728: if p_commit = FND_API.G_TRUE then

Line 1732: fnd_msg_pub.add_exc_msg(p_pkg_name => 'PA_TASK_PUB1',

1728: if p_commit = FND_API.G_TRUE then
1729: rollback to create_task_version;
1730: end if;
1731: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
1732: fnd_msg_pub.add_exc_msg(p_pkg_name => 'PA_TASK_PUB1',
1733: p_procedure_name => 'CREATE_TASK_VERSION',
1734: p_error_text => SUBSTRB(SQLERRM,1,240));
1735: raise;
1736: END Create_Task_Version;

Line 1833: pa_debug.init_err_stack ('PA_TASK_PUB1.UPDATE_TASK_VERSION');

1829: --l_carrying_out_org_id NUMBER;
1830: --l_task_manager_id NUMBER;
1831: BEGIN
1832:
1833: pa_debug.init_err_stack ('PA_TASK_PUB1.UPDATE_TASK_VERSION');
1834:
1835: IF (p_debug_mode = 'Y') THEN
1836: pa_debug.debug('PA_TASK_PUB1.UPDATE_TASK_VERSION begin');
1837: END IF;

Line 1836: pa_debug.debug('PA_TASK_PUB1.UPDATE_TASK_VERSION begin');

1832:
1833: pa_debug.init_err_stack ('PA_TASK_PUB1.UPDATE_TASK_VERSION');
1834:
1835: IF (p_debug_mode = 'Y') THEN
1836: pa_debug.debug('PA_TASK_PUB1.UPDATE_TASK_VERSION begin');
1837: END IF;
1838:
1839: IF (p_commit = FND_API.G_TRUE) THEN
1840: savepoint update_Task_version;

Line 1963: pa_debug.debug('PA_TASK_PUB1.UPDATE_TASK_VERSION END');

1959: COMMIT;
1960: END IF;
1961:
1962: IF (p_debug_mode = 'Y') THEN
1963: pa_debug.debug('PA_TASK_PUB1.UPDATE_TASK_VERSION END');
1964: END IF;
1965: EXCEPTION
1966: when FND_API.G_EXC_ERROR then
1967: if p_commit = FND_API.G_TRUE then

Line 1976: fnd_msg_pub.add_exc_msg(p_pkg_name => 'PA_TASK_PUB1',

1972: if p_commit = FND_API.G_TRUE then
1973: rollback to update_task_version;
1974: end if;
1975: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
1976: fnd_msg_pub.add_exc_msg(p_pkg_name => 'PA_TASK_PUB1',
1977: p_procedure_name => 'UPDATE_TASK_VERSION',
1978: p_error_text => SUBSTRB(SQLERRM,1,240));
1979: when OTHERS then
1980: if p_commit = FND_API.G_TRUE then

Line 1984: fnd_msg_pub.add_exc_msg(p_pkg_name => 'PA_TASK_PUB1',

1980: if p_commit = FND_API.G_TRUE then
1981: rollback to update_task_version;
1982: end if;
1983: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
1984: fnd_msg_pub.add_exc_msg(p_pkg_name => 'PA_TASK_PUB1',
1985: p_procedure_name => 'UPDATE_TASK_VERSION',
1986: p_error_text => SUBSTRB(SQLERRM,1,240));
1987: raise;
1988: END update_task_version;

Line 2139: pa_debug.init_err_stack ('PA_TASK_PUB1.DELETE_TASK_VERSION');

2135: l_linked_task VARCHAR2(1);
2136:
2137: BEGIN
2138:
2139: pa_debug.init_err_stack ('PA_TASK_PUB1.DELETE_TASK_VERSION');
2140:
2141: IF (p_debug_mode = 'Y') THEN
2142: pa_debug.debug('PA_TASK_PUB1.DELETE_TASK_VERSION begin');
2143: END IF;

Line 2142: pa_debug.debug('PA_TASK_PUB1.DELETE_TASK_VERSION begin');

2138:
2139: pa_debug.init_err_stack ('PA_TASK_PUB1.DELETE_TASK_VERSION');
2140:
2141: IF (p_debug_mode = 'Y') THEN
2142: pa_debug.debug('PA_TASK_PUB1.DELETE_TASK_VERSION begin');
2143: END IF;
2144:
2145: IF (p_commit = FND_API.G_TRUE) THEN
2146: savepoint delete_Task_version;

Line 2490: pa_debug.debug('PA_TASK_PUB1.DELETE_TASK_VERSION END');

2486: COMMIT;
2487: END IF;
2488:
2489: IF (p_debug_mode = 'Y') THEN
2490: pa_debug.debug('PA_TASK_PUB1.DELETE_TASK_VERSION END');
2491: END IF;
2492: EXCEPTION
2493: when FND_API.G_EXC_ERROR then
2494: if p_commit = FND_API.G_TRUE then

Line 2503: fnd_msg_pub.add_exc_msg(p_pkg_name => 'PA_TASK_PUB1',

2499: if p_commit = FND_API.G_TRUE then
2500: rollback to delete_task_version;
2501: end if;
2502: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
2503: fnd_msg_pub.add_exc_msg(p_pkg_name => 'PA_TASK_PUB1',
2504: p_procedure_name => 'DELETE_TASK_VERSION',
2505: p_error_text => SUBSTRB(SQLERRM,1,240));
2506: when OTHERS then
2507: if p_commit = FND_API.G_TRUE then

Line 2511: fnd_msg_pub.add_exc_msg(p_pkg_name => 'PA_TASK_PUB1',

2507: if p_commit = FND_API.G_TRUE then
2508: rollback to delete_task_version;
2509: end if;
2510: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
2511: fnd_msg_pub.add_exc_msg(p_pkg_name => 'PA_TASK_PUB1',
2512: p_procedure_name => 'DELETE_TASK_VERSION',
2513: p_error_text => SUBSTRB(SQLERRM,1,240));
2514: raise;
2515: END delete_task_version;

Line 2635: pa_debug.init_err_stack ('PA_TASK_PUB1.create_schedule_VERSION');

2631: l_data VARCHAR2(250);
2632: l_msg_index_out NUMBER;
2633: l_error_msg_code VARCHAR2(250);
2634: BEGIN
2635: pa_debug.init_err_stack ('PA_TASK_PUB1.create_schedule_VERSION');
2636:
2637: IF (p_debug_mode = 'Y') THEN
2638: pa_debug.debug('PA_TASK_PUB1.CREATE_SCHEDULE_VERSION begin');
2639: END IF;

Line 2638: pa_debug.debug('PA_TASK_PUB1.CREATE_SCHEDULE_VERSION begin');

2634: BEGIN
2635: pa_debug.init_err_stack ('PA_TASK_PUB1.create_schedule_VERSION');
2636:
2637: IF (p_debug_mode = 'Y') THEN
2638: pa_debug.debug('PA_TASK_PUB1.CREATE_SCHEDULE_VERSION begin');
2639: END IF;
2640:
2641: IF (p_commit = FND_API.G_TRUE) THEN
2642: savepoint create_schedule_version;

Line 2737: pa_debug.debug('PA_TASK_PUB1.CREATE_SCHEDULE_VERSION END');

2733: COMMIT;
2734: END IF;
2735:
2736: IF (p_debug_mode = 'Y') THEN
2737: pa_debug.debug('PA_TASK_PUB1.CREATE_SCHEDULE_VERSION END');
2738: END IF;
2739: EXCEPTION
2740: when FND_API.G_EXC_ERROR then
2741: if p_commit = FND_API.G_TRUE then

Line 2750: fnd_msg_pub.add_exc_msg(p_pkg_name => 'PA_TASK_PUB1',

2746: if p_commit = FND_API.G_TRUE then
2747: rollback to create_schedule_version;
2748: end if;
2749: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
2750: fnd_msg_pub.add_exc_msg(p_pkg_name => 'PA_TASK_PUB1',
2751: p_procedure_name => 'CREATE_SCHEDULE_VERSION',
2752: p_error_text => SUBSTRB(SQLERRM,1,240));
2753: when OTHERS then
2754: if p_commit = FND_API.G_TRUE then

Line 2758: fnd_msg_pub.add_exc_msg(p_pkg_name => 'PA_TASK_PUB1',

2754: if p_commit = FND_API.G_TRUE then
2755: rollback to create_schedule_version;
2756: end if;
2757: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
2758: fnd_msg_pub.add_exc_msg(p_pkg_name => 'PA_TASK_PUB1',
2759: p_procedure_name => 'CREATE_SCHEDULE_VERSION',
2760: p_error_text => SUBSTRB(SQLERRM,1,240));
2761: raise;
2762:

Line 2938: pa_debug.init_err_stack ('PA_TASK_PUB1.update_schedule_VERSION');

2934: -- end hyau Bug 2852753
2935:
2936: BEGIN
2937:
2938: pa_debug.init_err_stack ('PA_TASK_PUB1.update_schedule_VERSION');
2939:
2940: IF (p_debug_mode = 'Y') THEN
2941: pa_debug.debug('PA_TASK_PUB1.update_SCHEDULE_VERSION begin');
2942: END IF;

Line 2941: pa_debug.debug('PA_TASK_PUB1.update_SCHEDULE_VERSION begin');

2937:
2938: pa_debug.init_err_stack ('PA_TASK_PUB1.update_schedule_VERSION');
2939:
2940: IF (p_debug_mode = 'Y') THEN
2941: pa_debug.debug('PA_TASK_PUB1.update_SCHEDULE_VERSION begin');
2942: END IF;
2943:
2944: IF (p_commit = FND_API.G_TRUE) THEN
2945: savepoint update_schedule_version;

Line 3196: pa_debug.debug('PA_TASK_PUB1.UPDATE_SCHEDULE_VERSION END');

3192: COMMIT;
3193: END IF;
3194:
3195: IF (p_debug_mode = 'Y') THEN
3196: pa_debug.debug('PA_TASK_PUB1.UPDATE_SCHEDULE_VERSION END');
3197: END IF;
3198: EXCEPTION
3199: when FND_API.G_EXC_ERROR then
3200: if p_commit = FND_API.G_TRUE then

Line 3209: fnd_msg_pub.add_exc_msg(p_pkg_name => 'PA_TASK_PUB1',

3205: if p_commit = FND_API.G_TRUE then
3206: rollback to update_schedule_version;
3207: end if;
3208: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
3209: fnd_msg_pub.add_exc_msg(p_pkg_name => 'PA_TASK_PUB1',
3210: p_procedure_name => 'UPDATE_SCHEDULE_VERSION',
3211: p_error_text => SUBSTRB(SQLERRM,1,240));
3212: when OTHERS then
3213: if p_commit = FND_API.G_TRUE then

Line 3217: fnd_msg_pub.add_exc_msg(p_pkg_name => 'PA_TASK_PUB1',

3213: if p_commit = FND_API.G_TRUE then
3214: rollback to update_schedule_version;
3215: end if;
3216: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
3217: fnd_msg_pub.add_exc_msg(p_pkg_name => 'PA_TASK_PUB1',
3218: p_procedure_name => 'UPDATE_SCHEDULE_VERSION',
3219: p_error_text => SUBSTRB(SQLERRM,1,240));
3220: raise;
3221: END Update_Schedule_Version;

Line 3759: pa_debug.init_err_stack ('PA_TASK_PUB1.COPY_TASK');

3755:
3756: -- 3905123 end
3757:
3758: BEGIN
3759: pa_debug.init_err_stack ('PA_TASK_PUB1.COPY_TASK');
3760:
3761: IF (p_debug_mode = 'Y') THEN
3762: pa_debug.debug('PA_TASK_PUB1.COPY_TASK begin');
3763: END IF;

Line 3762: pa_debug.debug('PA_TASK_PUB1.COPY_TASK begin');

3758: BEGIN
3759: pa_debug.init_err_stack ('PA_TASK_PUB1.COPY_TASK');
3760:
3761: IF (p_debug_mode = 'Y') THEN
3762: pa_debug.debug('PA_TASK_PUB1.COPY_TASK begin');
3763: END IF;
3764:
3765: IF (p_commit = FND_API.G_TRUE) THEN
3766: savepoint copy_task;

Line 3778: PA_TASK_PUB1.G_CALL_PJI_ROLLUP := 'N';

3774: FND_MSG_PUB.initialize;
3775: END IF;
3776:
3777: --bug 4075697 copy_task
3778: PA_TASK_PUB1.G_CALL_PJI_ROLLUP := 'N';
3779: --bug 4075697
3780:
3781: --3035902: process update flag changes
3782: l_wp_process_flag := 'N';

Line 4259: --dbms_output.put_line( 'Before PA_TASK_PUB1.Create_Task' );

4255: END IF;
4256: l_structure_id := p_dest_structure_id ;
4257: /*4201927 */
4258:
4259: --dbms_output.put_line( 'Before PA_TASK_PUB1.Create_Task' );
4260: --dbms_output.put_line( 'Org Id '||cur_proj_elems_rec.carrying_out_organization_id);
4261:
4262: /*4201927 : This Copy API not used in Move Task Version Context , Hence Commenting
4263: IF (p_called_from_api <> 'MOVE_TASK_VERSION') THEN */

Line 4363: ----dbms_output.put_line( 'Before PA_TASK_PUB1.Create_Task_Version' );

4359: /* This code need not execute for each and every task in LOOP
4360: 4201927 : Moved this code to tagging marked by <>
4361: -- Start of block moved
4362:
4363: ----dbms_output.put_line( 'Before PA_TASK_PUB1.Create_Task_Version' );
4364: --hsiu added for task version status changes
4365: IF (l_template_flag = 'N') THEN
4366: --check if structure is shared
4367: -- if shared, check if versioned

Line 4634: PA_TASK_PUB1.Create_Task_Version(

4630: END IF;
4631: --end bug 2846700
4632:
4633:
4634: PA_TASK_PUB1.Create_Task_Version(
4635: p_api_version => p_api_version
4636: ,p_init_msg_list => p_init_msg_list
4637: ,p_commit => p_commit
4638: ,p_validate_only => p_validate_only

Line 4722: --dbms_output.put_line( 'Before PA_TASK_PUB1.Create_Scheduele_version' );

4718: FETCH cur_struc_type INTO l_dummy_char;
4719: IF cur_struc_type%FOUND
4720: THEN
4721:
4722: --dbms_output.put_line( 'Before PA_TASK_PUB1.Create_Scheduele_version' );
4723:
4724: /*4201927 : This Copy API not called in Move Task Version Context.
4725: Hence Commenting
4726: IF p_called_from_api <> 'MOVE_TASK_VERSION'

Line 5083: fnd_msg_pub.add_exc_msg(p_pkg_name => 'PA_TASK_PUB1',

5079: ,x_msg_data => l_msg_data
5080: );
5081: EXCEPTION
5082: WHEN OTHERS THEN
5083: fnd_msg_pub.add_exc_msg(p_pkg_name => 'PA_TASK_PUB1',
5084: p_procedure_name => 'COPY_TASK',
5085: p_error_text => SUBSTRB('pa_fp_planning_transaction_pub.copy_planning_transactions:'||SQLERRM,1,240));
5086: RAISE FND_API.G_EXC_ERROR;
5087: END;

Line 5150: fnd_msg_pub.add_exc_msg(p_pkg_name => 'PA_TASK_PUB1',

5146: );
5147: END IF;
5148: EXCEPTION
5149: WHEN OTHERS THEN
5150: fnd_msg_pub.add_exc_msg(p_pkg_name => 'PA_TASK_PUB1',
5151: p_procedure_name => 'COPY_TASK',
5152: p_error_text => SUBSTRB('pa_fp_planning_transaction_pub.delete_planning_transactions:'||SQLERRM,1,240));
5153: RAISE FND_API.G_EXC_ERROR;
5154: END;

Line 5214: fnd_msg_pub.add_exc_msg(p_pkg_name => 'PA_TASK_PUB1',

5210: ,x_msg_data => l_msg_data
5211: );
5212: EXCEPTION
5213: WHEN OTHERS THEN
5214: fnd_msg_pub.add_exc_msg(p_pkg_name => 'PA_TASK_PUB1',
5215: p_procedure_name => 'COPY_TASK',
5216: p_error_text => SUBSTRB('pa_fp_planning_transaction_pub.copy_planning_transactions:'||SQLERRM,1,240));
5217: RAISE FND_API.G_EXC_ERROR;
5218: END;

Line 5274: PA_TASK_PUB1.G_CALL_PJI_ROLLUP := NULL;

5270: --END IF;
5271: --3035902: process update flag changes
5272:
5273: --bug 4149392
5274: PA_TASK_PUB1.G_CALL_PJI_ROLLUP := NULL;
5275: --end bug 4149392
5276:
5277: x_return_status := FND_API.G_RET_STS_SUCCESS;
5278:

Line 5284: pa_debug.debug('PA_TASK_PUB1.COPY_TASK END');

5280: COMMIT;
5281: END IF;
5282:
5283: IF (p_debug_mode = 'Y') THEN
5284: pa_debug.debug('PA_TASK_PUB1.COPY_TASK END');
5285: END IF;
5286: EXCEPTION
5287: when FND_API.G_EXC_ERROR then
5288: if p_commit = FND_API.G_TRUE then

Line 5297: fnd_msg_pub.add_exc_msg(p_pkg_name => 'PA_TASK_PUB1',

5293: if p_commit = FND_API.G_TRUE then
5294: rollback to Copy_Task;
5295: end if;
5296: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
5297: fnd_msg_pub.add_exc_msg(p_pkg_name => 'PA_TASK_PUB1',
5298: p_procedure_name => 'COPY_TASK',
5299: p_error_text => SUBSTRB(SQLERRM,1,240));
5300: when OTHERS then
5301: if p_commit = FND_API.G_TRUE then

Line 5305: fnd_msg_pub.add_exc_msg(p_pkg_name => 'PA_TASK_PUB1',

5301: if p_commit = FND_API.G_TRUE then
5302: rollback to Copy_Task;
5303: end if;
5304: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
5305: fnd_msg_pub.add_exc_msg(p_pkg_name => 'PA_TASK_PUB1',
5306: p_procedure_name => 'COPY_TASK',
5307: p_error_text => SUBSTRB(SQLERRM,1,240));
5308: raise;
5309: END Copy_Task;

Line 5595: pa_debug.init_err_stack ('PA_TASK_PUB1.MOVE_TASK_VERSION');

5591:
5592: BEGIN
5593:
5594:
5595: pa_debug.init_err_stack ('PA_TASK_PUB1.MOVE_TASK_VERSION');
5596:
5597: IF (p_debug_mode = 'Y') THEN
5598: pa_debug.debug('PA_TASK_PUB1.MOVE_TASK_VERSION begin');
5599: END IF;

Line 5598: pa_debug.debug('PA_TASK_PUB1.MOVE_TASK_VERSION begin');

5594:
5595: pa_debug.init_err_stack ('PA_TASK_PUB1.MOVE_TASK_VERSION');
5596:
5597: IF (p_debug_mode = 'Y') THEN
5598: pa_debug.debug('PA_TASK_PUB1.MOVE_TASK_VERSION begin');
5599: END IF;
5600:
5601: IF (p_commit = FND_API.G_TRUE) THEN
5602: savepoint move_task_version;

Line 5614: PA_TASK_PUB1.G_CALL_PJI_ROLLUP := 'N';

5610: FND_MSG_PUB.initialize;
5611: END IF;
5612:
5613: --bug 4075697
5614: PA_TASK_PUB1.G_CALL_PJI_ROLLUP := 'N';
5615: --bug 4075697
5616:
5617: IF p_called_from_bulk_api = 'Y'/*4269830*/
5618: THEN

Line 5934: PA_TASK_PUB1.Update_Task_Version

5930: p_msg_name => 'PA_PS_CHK_DELIV_UPDATE');
5931: RAISE FND_API.G_EXC_ERROR;
5932: END IF;
5933: --
5934: PA_TASK_PUB1.Update_Task_Version
5935: ( p_validate_only => FND_API.G_FALSE,
5936: p_ref_task_version_id => p_ref_task_version_id,
5937: p_peer_or_sub => p_peer_or_sub,
5938: p_task_version_id => p_task_version_id,

Line 6458: fnd_msg_pub.add_exc_msg(p_pkg_name => 'PA_TASK_PUB1',

6454: );
6455: END IF;
6456: EXCEPTION
6457: WHEN OTHERS THEN
6458: fnd_msg_pub.add_exc_msg(p_pkg_name => 'PA_TASK_PUB1',
6459: p_procedure_name => 'MOVE_TASK_VERSION',
6460: p_error_text => SUBSTRB('pa_fp_planning_transaction_pub.delete_planning_transactions:'||SQLERRM,1,240));
6461: RAISE FND_API.G_EXC_ERROR;
6462: END;

Line 6482: PA_TASK_PUB1.G_CALL_PJI_ROLLUP := NULL;

6478: END IF;
6479: end;
6480:
6481: --bug 4149392
6482: PA_TASK_PUB1.G_CALL_PJI_ROLLUP := NULL;
6483: --end bug 4149392
6484:
6485: x_return_status := FND_API.G_RET_STS_SUCCESS;
6486:

Line 6492: pa_debug.debug('PA_TASK_PUB1.MOVE_TASK_VERSION END');

6488: COMMIT;
6489: END IF;
6490:
6491: IF (p_debug_mode = 'Y') THEN
6492: pa_debug.debug('PA_TASK_PUB1.MOVE_TASK_VERSION END');
6493: END IF;
6494: EXCEPTION
6495: when FND_API.G_EXC_ERROR then
6496: if p_commit = FND_API.G_TRUE then

Line 6505: fnd_msg_pub.add_exc_msg(p_pkg_name => 'PA_TASK_PUB1',

6501: if p_commit = FND_API.G_TRUE then
6502: rollback to move_task_version;
6503: end if;
6504: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
6505: fnd_msg_pub.add_exc_msg(p_pkg_name => 'PA_TASK_PUB1',
6506: p_procedure_name => 'MOVE_TASK_VERSION',
6507: p_error_text => SUBSTRB(SQLERRM,1,240));
6508: when OTHERS then
6509: if p_commit = FND_API.G_TRUE then

Line 6513: fnd_msg_pub.add_exc_msg(p_pkg_name => 'PA_TASK_PUB1',

6509: if p_commit = FND_API.G_TRUE then
6510: rollback to move_task_version;
6511: end if;
6512: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
6513: fnd_msg_pub.add_exc_msg(p_pkg_name => 'PA_TASK_PUB1',
6514: p_procedure_name => 'MOVE_TASK_VERSION',
6515: p_error_text => SUBSTRB(SQLERRM,1,240));
6516: raise;
6517: END Move_Task_version;

Line 6629: pa_debug.init_err_stack ('PA_TASK_PUB1.INDENT_TASK_VERSION');

6625: l_parent_ver_id NUMBER;
6626: l_error_msg_code VARCHAR2(30);
6627:
6628: BEGIN
6629: pa_debug.init_err_stack ('PA_TASK_PUB1.INDENT_TASK_VERSION');
6630:
6631: IF (p_debug_mode = 'Y') THEN
6632: pa_debug.debug('PA_TASK_PUB1.INDENT_TASK_VERSION begin');
6633: END IF;

Line 6632: pa_debug.debug('PA_TASK_PUB1.INDENT_TASK_VERSION begin');

6628: BEGIN
6629: pa_debug.init_err_stack ('PA_TASK_PUB1.INDENT_TASK_VERSION');
6630:
6631: IF (p_debug_mode = 'Y') THEN
6632: pa_debug.debug('PA_TASK_PUB1.INDENT_TASK_VERSION begin');
6633: END IF;
6634:
6635: IF (p_commit = FND_API.G_TRUE) THEN
6636: savepoint indent_task_version;

Line 6841: PA_TASK_PUB1.Update_Task_Version

6837:
6838:
6839: --dbms_output.put_line( 'Indent Task Stage 9 ' );
6840:
6841: PA_TASK_PUB1.Update_Task_Version
6842: ( p_validate_only => FND_API.G_FALSE,
6843: p_ref_task_version_id => l_ref_task_version_id,
6844: p_peer_or_sub => l_peer_or_sub,
6845: p_task_version_id => p_task_version_id,

Line 7044: pa_debug.debug('PA_TASK_PUB1.INDENT_TASK_VERSION END');

7040: COMMIT;
7041: END IF;
7042:
7043: IF (p_debug_mode = 'Y') THEN
7044: pa_debug.debug('PA_TASK_PUB1.INDENT_TASK_VERSION END');
7045: END IF;
7046:
7047: EXCEPTION
7048: when FND_API.G_EXC_ERROR then

Line 7058: fnd_msg_pub.add_exc_msg(p_pkg_name => 'PA_TASK_PUB1',

7054: if p_commit = FND_API.G_TRUE then
7055: rollback to indent_task_version;
7056: end if;
7057: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
7058: fnd_msg_pub.add_exc_msg(p_pkg_name => 'PA_TASK_PUB1',
7059: p_procedure_name => 'INDENT_TASK_VERSION',
7060: p_error_text => SUBSTRB(SQLERRM,1,240));
7061: when OTHERS then
7062: if p_commit = FND_API.G_TRUE then

Line 7066: fnd_msg_pub.add_exc_msg(p_pkg_name => 'PA_TASK_PUB1',

7062: if p_commit = FND_API.G_TRUE then
7063: rollback to indent_task_version;
7064: end if;
7065: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
7066: fnd_msg_pub.add_exc_msg(p_pkg_name => 'PA_TASK_PUB1',
7067: p_procedure_name => 'INDENT_TASK_VERSION',
7068: p_error_text => SUBSTRB(SQLERRM,1,240));
7069: raise;
7070:

Line 7191: pa_debug.init_err_stack ('PA_TASK_PUB1.OUTDENT_TASK_VERSION');

7187: and relationship_type = 'S';
7188: l_parent_ver_id NUMBER;
7189: l_error_msg_code VARCHAR2(30);
7190: BEGIN
7191: pa_debug.init_err_stack ('PA_TASK_PUB1.OUTDENT_TASK_VERSION');
7192:
7193: IF (p_debug_mode = 'Y') THEN
7194: pa_debug.debug('PA_TASK_PUB1.OUTDENT_TASK_VERSION begin');
7195: END IF;

Line 7194: pa_debug.debug('PA_TASK_PUB1.OUTDENT_TASK_VERSION begin');

7190: BEGIN
7191: pa_debug.init_err_stack ('PA_TASK_PUB1.OUTDENT_TASK_VERSION');
7192:
7193: IF (p_debug_mode = 'Y') THEN
7194: pa_debug.debug('PA_TASK_PUB1.OUTDENT_TASK_VERSION begin');
7195: END IF;
7196:
7197: IF (p_commit = FND_API.G_TRUE) THEN
7198: savepoint outdent_task_version;

Line 7326: PA_TASK_PUB1.Update_Task_Version

7322: --task status changes ends
7323:
7324: --dbms_output.put_line( 'Before Update_Task_Version ' );
7325:
7326: PA_TASK_PUB1.Update_Task_Version
7327: ( p_validate_only => FND_API.G_FALSE,
7328: p_ref_task_version_id => l_ref_task_version_id,
7329: p_peer_or_sub => 'PEER',
7330: p_task_version_id => p_task_version_id,

Line 7528: pa_debug.debug('PA_TASK_PUB1.OUTDENT_TASK_VERSION END');

7524: COMMIT;
7525: END IF;
7526:
7527: IF (p_debug_mode = 'Y') THEN
7528: pa_debug.debug('PA_TASK_PUB1.OUTDENT_TASK_VERSION END');
7529: END IF;
7530:
7531: EXCEPTION
7532: when FND_API.G_EXC_ERROR then

Line 7542: fnd_msg_pub.add_exc_msg(p_pkg_name => 'PA_TASK_PUB1',

7538: if p_commit = FND_API.G_TRUE then
7539: rollback to outdent_task_version;
7540: end if;
7541: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
7542: fnd_msg_pub.add_exc_msg(p_pkg_name => 'PA_TASK_PUB1',
7543: p_procedure_name => 'OUTDENT_TASK_VERSION',
7544: p_error_text => SUBSTRB(SQLERRM,1,240));
7545: when OTHERS then
7546: if p_commit = FND_API.G_TRUE then

Line 7550: fnd_msg_pub.add_exc_msg(p_pkg_name => 'PA_TASK_PUB1',

7546: if p_commit = FND_API.G_TRUE then
7547: rollback to outdent_task_version;
7548: end if;
7549: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
7550: fnd_msg_pub.add_exc_msg(p_pkg_name => 'PA_TASK_PUB1',
7551: p_procedure_name => 'OUTDENT_TASK_VERSION',
7552: p_error_text => SUBSTRB(SQLERRM,1,240));
7553: raise;
7554: END Outdent_Task_Version;

Line 7917: --my_error_msg( 'before PA_TASK_PUB1.CREATE_TASK' );

7913: l_peer_or_sub := 'SUB';
7914: end if;
7915: end if;
7916:
7917: --my_error_msg( 'before PA_TASK_PUB1.CREATE_TASK' );
7918:
7919: OPEN cur_ref_proj_elem_id( l_ref_task_ver_id );
7920: FETCH cur_ref_proj_elem_id INTO l_ref_proj_eleme_id; --For ref task id
7921: CLOSE cur_ref_proj_elem_id;

Line 7981: PA_TASK_PUB1.CREATE_TASK

7977: END IF;
7978: END IF;
7979: --3035902: end process update flag changes
7980:
7981: PA_TASK_PUB1.CREATE_TASK
7982: ( p_validate_only => FND_API.G_FALSE
7983: ,p_object_type => 'PA_TASKS'
7984: ,p_project_id => p_project_id
7985: ,p_ref_task_id => l_ref_proj_eleme_id

Line 8017: --my_error_msg( 'before PA_TASK_PUB1.CREATE_TASK_VERSION' );

8013: end if;
8014: raise API_ERROR;
8015: end if;
8016:
8017: --my_error_msg( 'before PA_TASK_PUB1.CREATE_TASK_VERSION' );
8018:
8019: /* commented out because flag value is set before create task
8020: --bug 3010538
8021: IF (l_shared = 'N') AND

Line 8135: PA_TASK_PUB1.CREATE_TASK_VERSION

8131: --end task version status changes
8132:
8133:
8134: --CREATE_TASK_VERSION
8135: PA_TASK_PUB1.CREATE_TASK_VERSION
8136: ( p_validate_only => FND_API.G_FALSE
8137: ,p_ref_task_version_id => l_ref_task_ver_id
8138: ,p_peer_or_sub => l_peer_or_sub
8139: ,p_task_id => l_task_id

Line 8192: PA_TASK_PUB1.CREATE_SCHEDULE_VERSION

8188:
8189: --my_error_msg( 'before PA_PROJECT_STRUCTURE_UTILS.GET_STRUC_TYPE_FOR_VERSION' );
8190:
8191: if PA_PROJECT_STRUCTURE_UTILS.GET_STRUC_TYPE_FOR_VERSION(p_structure_version_id, 'WORKPLAN') = 'Y' then
8192: PA_TASK_PUB1.CREATE_SCHEDULE_VERSION
8193: ( p_validate_only => FND_API.G_FALSE
8194: ,p_element_version_id => l_task_version_id
8195: ,p_scheduled_start_date => nvl(p_scheduled_start_date(i), sysdate)
8196: ,p_scheduled_end_date => nvl(p_scheduled_finish_date(i),nvl(p_scheduled_start_date(i), sysdate))

Line 8239: PA_TASK_PUB1.call_add_planning_txns(

8235:
8236:
8237: --bug 3301192 call the budgets apis
8238: if PA_PROJECT_STRUCTURE_UTILS.GET_STRUC_TYPE_FOR_VERSION(p_structure_version_id, 'WORKPLAN') = 'Y' then /* this api called should have been cached but we dont have time now to do this. */
8239: PA_TASK_PUB1.call_add_planning_txns(
8240: p_tasks_ver_ids => l_tasks_ver_ids,
8241: p_planned_effort => p_planned_effort,
8242: p_project_id => p_project_id,
8243: p_structure_version_id => p_structure_version_id,

Line 8375: PA_TASK_PUB1.Calc_Task_Weights(

8371: END IF;
8372: END IF;
8373:
8374: -- anlee task weighting
8375: PA_TASK_PUB1.Calc_Task_Weights(
8376: p_element_versions => l_tasks_ver_ids
8377: ,p_outline_level => p_outline_level
8378: ,p_top_sub_count => l_top_sub_count
8379: ,x_return_status => l_return_status

Line 8557: l_module_name VARCHAR2(100) := 'pa.plsql.PA_TASK_PUB1';

8553: l_project_id NUMBER;
8554:
8555: --Start Changes for bug 3083950
8556: l_debug_mode VARCHAR2(1);
8557: l_module_name VARCHAR2(100) := 'pa.plsql.PA_TASK_PUB1';
8558: l_temp_number NUMBER(17,2);
8559: l_diff_number NUMBER;
8560: l_sum_temp_number NUMBER(17,4);
8561: l_constant_temp_number NUMBER(17,4) := 0.0100;

Line 8587: pa_debug.set_curr_function( p_function => 'PA_TASK_PUB1.CALC_TASK_WEIGHTS',

8583: pa_debug.write(l_module_name,pa_debug.g_err_stage,
8584: l_debug_level2);
8585:
8586:
8587: pa_debug.set_curr_function( p_function => 'PA_TASK_PUB1.CALC_TASK_WEIGHTS',
8588: p_debug_mode => l_debug_mode );
8589:
8590: END IF;
8591:

Line 8970: fnd_msg_pub.add_exc_msg(p_pkg_name => 'PA_TASK_PUB1',

8966: x_return_status := FND_API.G_RET_STS_SUCCESS;
8967: EXCEPTION
8968: WHEN OTHERS THEN
8969: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
8970: fnd_msg_pub.add_exc_msg(p_pkg_name => 'PA_TASK_PUB1',
8971: p_procedure_name => 'CALC_TASK_WEIGHTS',
8972: p_error_text => SUBSTRB(SQLERRM,1,240));
8973: IF l_debug_mode = 'Y' THEN
8974: pa_debug.reset_curr_function;

Line 9026: pa_debug.init_err_stack ('PA_TASK_PUB1.UPDATE_TASK_WEIGHTING');

9022: IS
9023:
9024: BEGIN
9025:
9026: pa_debug.init_err_stack ('PA_TASK_PUB1.UPDATE_TASK_WEIGHTING');
9027:
9028: IF (p_debug_mode = 'Y') THEN
9029: pa_debug.debug('PA_TASK_PUB1.UPDATE_TASK_WEIGHTING begin');
9030: END IF;

Line 9029: pa_debug.debug('PA_TASK_PUB1.UPDATE_TASK_WEIGHTING begin');

9025:
9026: pa_debug.init_err_stack ('PA_TASK_PUB1.UPDATE_TASK_WEIGHTING');
9027:
9028: IF (p_debug_mode = 'Y') THEN
9029: pa_debug.debug('PA_TASK_PUB1.UPDATE_TASK_WEIGHTING begin');
9030: END IF;
9031:
9032: IF (p_commit = FND_API.G_TRUE) THEN
9033: savepoint update_task_weighting;

Line 9060: fnd_msg_pub.add_exc_msg(p_pkg_name => 'PA_TASK_PUB1',

9056: if p_commit = FND_API.G_TRUE then
9057: rollback to update_task_weighting;
9058: end if;
9059: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
9060: fnd_msg_pub.add_exc_msg(p_pkg_name => 'PA_TASK_PUB1',
9061: p_procedure_name => 'UPDATE_TASK_WEIGHTING',
9062: p_error_text => SUBSTRB(SQLERRM,1,240));
9063: when OTHERS then
9064: if p_commit = FND_API.G_TRUE then

Line 9068: fnd_msg_pub.add_exc_msg(p_pkg_name => 'PA_TASK_PUB1',

9064: if p_commit = FND_API.G_TRUE then
9065: rollback to update_task_weighting;
9066: end if;
9067: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
9068: fnd_msg_pub.add_exc_msg(p_pkg_name => 'PA_TASK_PUB1',
9069: p_procedure_name => 'UPDATE_TASK_WEIGHTING',
9070: p_error_text => SUBSTRB(SQLERRM,1,240));
9071: raise;
9072:

Line 9375: pa_debug.init_err_stack ('PA_TASK_PUB1.INDENT_TASK_VERSION_BULK');

9371: --bug 4214825, end
9372:
9373: BEGIN
9374:
9375: pa_debug.init_err_stack ('PA_TASK_PUB1.INDENT_TASK_VERSION_BULK');
9376:
9377: IF (p_debug_mode = 'Y') THEN
9378: pa_debug.debug('PA_TASK_PUB1.INDENT_TASK_VERSION_BULK begin');
9379: END IF;

Line 9378: pa_debug.debug('PA_TASK_PUB1.INDENT_TASK_VERSION_BULK begin');

9374:
9375: pa_debug.init_err_stack ('PA_TASK_PUB1.INDENT_TASK_VERSION_BULK');
9376:
9377: IF (p_debug_mode = 'Y') THEN
9378: pa_debug.debug('PA_TASK_PUB1.INDENT_TASK_VERSION_BULK begin');
9379: END IF;
9380:
9381: IF (p_commit = FND_API.G_TRUE) THEN
9382: savepoint indent_task_version_bulk;

Line 9394: PA_TASK_PUB1.G_CALL_PJI_ROLLUP := 'N';

9390: FND_MSG_PUB.initialize;
9391: END IF;
9392:
9393: --bug 4075697
9394: PA_TASK_PUB1.G_CALL_PJI_ROLLUP := 'N';
9395: --bug 4075697
9396:
9397: --3035902: process update flag changes
9398: l_wp_process_flag := 'N';

Line 9711: PA_TASK_PUB1.Update_Task_Version

9707: /*
9708:
9709: The processing done by the followig two calls is made now as plsql table bulk processing
9710:
9711: PA_TASK_PUB1.Update_Task_Version
9712: ( p_validate_only => FND_API.G_FALSE,
9713: p_ref_task_version_id => l_ref_task_version_id,
9714: p_peer_or_sub => l_peer_or_sub,
9715: p_task_version_id => p_task_version_id,

Line 9734: /*** The following part should do the same task as done by PA_TASK_PUB1.Update_Task_Version and Update_wbs_numbers ***/

9730:
9731: */
9732:
9733:
9734: /*** The following part should do the same task as done by PA_TASK_PUB1.Update_Task_Version and Update_wbs_numbers ***/
9735:
9736: -- Logic Added for plsql table
9737: -- Basically earlier this was done thru update_task_version and update_wbs_numbers
9738:

Line 10480: fnd_msg_pub.add_exc_msg(p_pkg_name => 'PA_TASK_PUB1',

10476: );
10477: END IF;
10478: EXCEPTION
10479: WHEN OTHERS THEN
10480: fnd_msg_pub.add_exc_msg(p_pkg_name => 'PA_TASK_PUB1',
10481: p_procedure_name => 'INDENT_TASK_VERSION_BULK',
10482: p_error_text => SUBSTRB('pa_fp_planning_transaction_pub.delete_planning_transactions:'||SQLERRM,1,240));
10483: RAISE FND_API.G_EXC_ERROR;
10484: END;

Line 10504: PA_TASK_PUB1.G_CALL_PJI_ROLLUP := NULL;

10500: END IF; --<>
10501: END IF; --<>
10502:
10503: --bug 4149392
10504: PA_TASK_PUB1.G_CALL_PJI_ROLLUP := NULL;
10505: --end bug 4149392
10506:
10507: x_return_status := FND_API.G_RET_STS_SUCCESS;
10508:

Line 10514: pa_debug.debug('PA_TASK_PUB1.INDENT_TASK_VERSION_BULK END');

10510: COMMIT;
10511: END IF;
10512:
10513: IF (p_debug_mode = 'Y') THEN
10514: pa_debug.debug('PA_TASK_PUB1.INDENT_TASK_VERSION_BULK END');
10515: END IF;
10516:
10517: EXCEPTION
10518: when FND_API.G_EXC_ERROR then

Line 10528: fnd_msg_pub.add_exc_msg(p_pkg_name => 'PA_TASK_PUB1',

10524: if p_commit = FND_API.G_TRUE then
10525: rollback to indent_task_version_bulk;
10526: end if;
10527: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
10528: fnd_msg_pub.add_exc_msg(p_pkg_name => 'PA_TASK_PUB1',
10529: p_procedure_name => 'INDENT_TASK_VERSION_BULK',
10530: p_error_text => SUBSTRB(SQLERRM,1,240));
10531: when OTHERS then
10532: if p_commit = FND_API.G_TRUE then

Line 10536: fnd_msg_pub.add_exc_msg(p_pkg_name => 'PA_TASK_PUB1',

10532: if p_commit = FND_API.G_TRUE then
10533: rollback to indent_task_version_bulk;
10534: end if;
10535: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
10536: fnd_msg_pub.add_exc_msg(p_pkg_name => 'PA_TASK_PUB1',
10537: p_procedure_name => 'INDENT_TASK_VERSION_BULK',
10538: p_error_text => SUBSTRB(SQLERRM,1,240));
10539: raise;
10540:

Line 10881: pa_debug.init_err_stack ('PA_TASK_PUB1.OUTDENT_TASK_VERSION_BULK');

10877: l_fin_task_flag VARCHAR2(1);
10878:
10879: BEGIN
10880:
10881: pa_debug.init_err_stack ('PA_TASK_PUB1.OUTDENT_TASK_VERSION_BULK');
10882:
10883: IF (p_debug_mode = 'Y') THEN
10884: pa_debug.debug('PA_TASK_PUB1.OUTDENT_TASK_VERSION_BULK begin');
10885: END IF;

Line 10884: pa_debug.debug('PA_TASK_PUB1.OUTDENT_TASK_VERSION_BULK begin');

10880:
10881: pa_debug.init_err_stack ('PA_TASK_PUB1.OUTDENT_TASK_VERSION_BULK');
10882:
10883: IF (p_debug_mode = 'Y') THEN
10884: pa_debug.debug('PA_TASK_PUB1.OUTDENT_TASK_VERSION_BULK begin');
10885: END IF;
10886:
10887: IF (p_commit = FND_API.G_TRUE) THEN
10888: savepoint OUTDENT_task_version_bulk;

Line 10900: PA_TASK_PUB1.G_CALL_PJI_ROLLUP := 'N';

10896: FND_MSG_PUB.initialize;
10897: END IF;
10898:
10899: --bug 4075697
10900: PA_TASK_PUB1.G_CALL_PJI_ROLLUP := 'N';
10901: --bug 4075697
10902:
10903:
10904: --3035902: process update flag changes

Line 11057: pa_debug.debug('ERROR !!! PA_TASK_PUB1.OUTDENT_TASK_VERSION_BULK ');

11053: , src_proj_element_id
11054: , p_task_version_id),'N') = 'Y') then
11055:
11056: IF (p_debug_mode = 'Y') THEN
11057: pa_debug.debug('ERROR !!! PA_TASK_PUB1.OUTDENT_TASK_VERSION_BULK ');
11058: END IF;
11059:
11060: PA_UTILS.ADD_MESSAGE(p_app_short_name => 'PA',
11061: p_msg_name => 'PA_PS_TASK_HAS_SUB_PROJ');

Line 11146: PA_TASK_PUB1.Update_Task_Version

11142: /*
11143:
11144: The processing done by the followig two calls is made now as plsql table bulk processing
11145:
11146: PA_TASK_PUB1.Update_Task_Version
11147: ( p_validate_only => FND_API.G_FALSE,
11148: p_ref_task_version_id => l_ref_task_version_id,
11149: p_peer_or_sub => 'PEER',
11150: p_task_version_id => p_task_version_id,

Line 11170: /*** The following part should do the same task as done by PA_TASK_PUB1.Update_Task_Version and Update_wbs_numbers ***/

11166:
11167: */
11168:
11169:
11170: /*** The following part should do the same task as done by PA_TASK_PUB1.Update_Task_Version and Update_wbs_numbers ***/
11171:
11172: -- Logic Added for plsql table
11173: -- Basically earlier this was done thru update_task_version and update_wbs_numbers
11174:

Line 12117: fnd_msg_pub.add_exc_msg(p_pkg_name => 'PA_TASK_PUB1',

12113: );
12114: END IF;
12115: EXCEPTION
12116: WHEN OTHERS then
12117: fnd_msg_pub.add_exc_msg(p_pkg_name => 'PA_TASK_PUB1',
12118: p_procedure_name => 'OUTDENT_TASK_VERSION_BULK',
12119: p_error_text => SUBSTRB('pa_fp_planning_transaction_pub.delete_planning_transactions:'||SQLERRM,1,240));
12120: RAISE FND_API.G_EXC_ERROR;
12121: END;

Line 12141: PA_TASK_PUB1.G_CALL_PJI_ROLLUP := NULL;

12137: END IF; --<>
12138: --bug 3301192
12139:
12140: --bug 4149392
12141: PA_TASK_PUB1.G_CALL_PJI_ROLLUP := NULL;
12142: --end bug 4149392
12143:
12144: x_return_status := FND_API.G_RET_STS_SUCCESS;
12145:

Line 12151: pa_debug.debug('PA_TASK_PUB1.OUTDENT_TASK_VERSION_BULK END');

12147: COMMIT;
12148: END IF;
12149:
12150: IF (p_debug_mode = 'Y') THEN
12151: pa_debug.debug('PA_TASK_PUB1.OUTDENT_TASK_VERSION_BULK END');
12152: END IF;
12153:
12154: EXCEPTION
12155: when FND_API.G_EXC_ERROR then

Line 12165: fnd_msg_pub.add_exc_msg(p_pkg_name => 'PA_TASK_PUB1',

12161: if p_commit = FND_API.G_TRUE then
12162: rollback to OUTDENT_task_version_bulk;
12163: end if;
12164: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
12165: fnd_msg_pub.add_exc_msg(p_pkg_name => 'PA_TASK_PUB1',
12166: p_procedure_name => 'OUTDENT_TASK_VERSION_BULK',
12167: p_error_text => SUBSTRB(SQLERRM,1,240));
12168: when OTHERS then
12169: if p_commit = FND_API.G_TRUE then

Line 12173: fnd_msg_pub.add_exc_msg(p_pkg_name => 'PA_TASK_PUB1',

12169: if p_commit = FND_API.G_TRUE then
12170: rollback to OUTDENT_task_version_bulk;
12171: end if;
12172: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
12173: fnd_msg_pub.add_exc_msg(p_pkg_name => 'PA_TASK_PUB1',
12174: p_procedure_name => 'OUTDENT_TASK_VERSION_BULK',
12175: p_error_text => SUBSTRB(SQLERRM,1,240));
12176: raise;
12177:

Line 12274: PA_TASK_PUB1.Delete_Task_Version(p_task_version_id => p_task_version_id_tbl(i)

12270:
12271:
12272:
12273: -- call delete_task_version API
12274: PA_TASK_PUB1.Delete_Task_Version(p_task_version_id => p_task_version_id_tbl(i)
12275: ,p_record_version_number => p_record_version_number_tbl(i)
12276: ,p_structure_type => p_structure_type
12277: ,x_return_status => l_return_status
12278: ,x_msg_count => l_msg_count

Line 12373: ( p_pkg_name => 'PA_TASK_PUB1'

12369: -- savepoint should be issued only when p_commit
12370: -- is true, which is a missing parameter
12371: -- rollback to delete_bulk;
12372: FND_MSG_PUB.add_exc_msg
12373: ( p_pkg_name => 'PA_TASK_PUB1'
12374: ,p_procedure_name => 'DELETE_TASK_VERSION_IN_BULK' );
12375: IF l_debug_mode = 'Y' THEN
12376: pa_debug.write('DELETE_TASK_VERSION_IN_BULK' || G_PKG_NAME,SQLERRM,4);
12377: pa_debug.write('DELETE_TASK_VERSION_IN_BULK' || G_PKG_NAME,pa_debug.G_Err_Stack,4);

Line 12435: pa_debug.debug('PA_TASK_PUB1.UPDATE_TASK_ASSOCIATION START');

12431:
12432: x_return_status := FND_API.G_RET_STS_SUCCESS;
12433:
12434: IF (p_debug_mode = 'Y') THEN
12435: pa_debug.debug('PA_TASK_PUB1.UPDATE_TASK_ASSOCIATION START');
12436: END IF;
12437:
12438: IF FND_API.TO_BOOLEAN(nvl(p_init_msg_list,FND_API.G_FALSE)) THEN
12439: FND_MSG_PUB.initialize;

Line 12545: pa_debug.debug('PA_TASK_PUB1.UPDATE_TASK_ASSOCIATION END');

12541: END IF;
12542: END IF;
12543:
12544: IF (p_debug_mode = 'Y') THEN
12545: pa_debug.debug('PA_TASK_PUB1.UPDATE_TASK_ASSOCIATION END');
12546: END IF;
12547:
12548:
12549: EXCEPTION

Line 12563: fnd_msg_pub.add_exc_msg(p_pkg_name => 'PA_TASK_PUB1',

12559: END IF;
12560: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
12561: x_msg_count := FND_MSG_PUB.count_msg;
12562: --put message
12563: fnd_msg_pub.add_exc_msg(p_pkg_name => 'PA_TASK_PUB1',
12564: p_procedure_name => 'update_task_association',
12565: p_error_text => SUBSTRB(SQLERRM,1,240));
12566: RAISE;
12567:

Line 12608: pa_debug.debug('PA_TASK_PUB1.DELETE_TASK_ASSOCIATION START');

12604: BEGIN
12605: x_return_status := FND_API.G_RET_STS_SUCCESS;
12606:
12607: IF (p_debug_mode = 'Y') THEN
12608: pa_debug.debug('PA_TASK_PUB1.DELETE_TASK_ASSOCIATION START');
12609: END IF;
12610:
12611: IF FND_API.TO_BOOLEAN(nvl(p_init_msg_list,FND_API.G_FALSE)) THEN
12612: FND_MSG_PUB.initialize;

Line 12654: pa_debug.debug('PA_TASK_PUB1.DELETE_TASK_ASSOCIATIONS END');

12650: END IF;
12651:
12652:
12653: IF (p_debug_mode = 'Y') THEN
12654: pa_debug.debug('PA_TASK_PUB1.DELETE_TASK_ASSOCIATIONS END');
12655: END IF;
12656:
12657:
12658: EXCEPTION

Line 12672: fnd_msg_pub.add_exc_msg(p_pkg_name => 'PA_TASK_PUB1',

12668: END IF;
12669: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
12670: x_msg_count := FND_MSG_PUB.count_msg;
12671: --put message
12672: fnd_msg_pub.add_exc_msg(p_pkg_name => 'PA_TASK_PUB1',
12673: p_procedure_name => 'delete_all_task_associations',
12674: p_error_text => SUBSTRB(SQLERRM,1,240));
12675: RAISE;
12676:

Line 12716: fnd_msg_pub.add_exc_msg(p_pkg_name => 'PA_TASK_PUB1',

12712: WHEN OTHERS THEN
12713: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
12714: --x_msg_count := FND_MSG_PUB.count_msg;
12715: --put message
12716: fnd_msg_pub.add_exc_msg(p_pkg_name => 'PA_TASK_PUB1',
12717: p_procedure_name => 'delete_association',
12718: p_error_text => SUBSTRB(SQLERRM,1,240));
12719:
12720: RAISE;

Line 12862: pa_debug.debug('PA_TASK_PUB1.Delete_Proj_To_Task_Assoc START');

12858: BEGIN
12859: x_return_status := FND_API.G_RET_STS_SUCCESS;
12860:
12861: IF (p_debug_mode = 'Y') THEN
12862: pa_debug.debug('PA_TASK_PUB1.Delete_Proj_To_Task_Assoc START');
12863: END IF;
12864: IF FND_API.TO_BOOLEAN(nvl(p_init_msg_list,FND_API.G_FALSE)) THEN
12865: FND_MSG_PUB.initialize;
12866: END IF;

Line 12906: pa_debug.debug('PA_TASK_PUB1.Delete_Proj_To_Task_Assoc END');

12902: END IF;
12903: END IF;
12904:
12905: IF (p_debug_mode = 'Y') THEN
12906: pa_debug.debug('PA_TASK_PUB1.Delete_Proj_To_Task_Assoc END');
12907: END IF;
12908:
12909: EXCEPTION
12910: WHEN FND_API.G_EXC_ERROR THEN

Line 12922: fnd_msg_pub.add_exc_msg(p_pkg_name => 'PA_TASK_PUB1',

12918: ROLLBACK to delete_prj_to_task_assoc;
12919: END IF;
12920: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
12921: --put message
12922: fnd_msg_pub.add_exc_msg(p_pkg_name => 'PA_TASK_PUB1',
12923: p_procedure_name => 'delete_proj_to_task_assoc',
12924: p_error_text => SUBSTRB(SQLERRM,1,240));
12925: RAISE;
12926: END Delete_Proj_To_Task_Assoc;

Line 12979: pa_debug.debug('PA_TASK_PUB1.Copy_Task_Associations START');

12975:
12976: BEGIN
12977:
12978: IF (p_debug_mode = 'Y') THEN
12979: pa_debug.debug('PA_TASK_PUB1.Copy_Task_Associations START');
12980: END IF;
12981:
12982: x_return_status := FND_API.G_RET_STS_SUCCESS;
12983:

Line 13053: pa_debug.debug('PA_TASK_PUB1.Copy_Task_Associations END');

13049: END IF;
13050: END IF;
13051:
13052: IF (p_debug_mode = 'Y') THEN
13053: pa_debug.debug('PA_TASK_PUB1.Copy_Task_Associations END');
13054: END IF;
13055:
13056: EXCEPTION
13057: WHEN FND_API.G_EXC_ERROR THEN

Line 13069: fnd_msg_pub.add_exc_msg(p_pkg_name => 'PA_TASK_PUB1',

13065: ROLLBACK to copy_task_associations;
13066: END IF;
13067: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
13068: --put message
13069: fnd_msg_pub.add_exc_msg(p_pkg_name => 'PA_TASK_PUB1',
13070: p_procedure_name => 'Copy_Task_Associations',
13071: p_error_text => SUBSTRB(SQLERRM,1,240));
13072: RAISE;
13073: END Copy_Task_Associations;

Line 13155: fnd_msg_pub.add_exc_msg(p_pkg_name => 'PA_TASK_PUB1',

13151: ,x_msg_data => l_msg_data
13152: );
13153: EXCEPTION
13154: WHEN OTHERS THEN
13155: fnd_msg_pub.add_exc_msg(p_pkg_name => 'PA_TASK_PUB1',
13156: p_procedure_name => 'call_add_planning_txns',
13157: p_error_text => SUBSTRB('pa_fp_planning_transaction_pub.add_planning_transactions:'||SQLERRM,1,240));
13158: raise API_ERROR;
13159: END;

Line 13182: fnd_msg_pub.add_exc_msg(p_pkg_name => 'PA_TASK_PUB1',

13178: WHEN API_ERROR THEN
13179: x_return_status := FND_API.G_RET_STS_ERROR;
13180: WHEN OTHERS THEN
13181: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
13182: fnd_msg_pub.add_exc_msg(p_pkg_name => 'PA_TASK_PUB1',
13183: p_procedure_name => 'call_add_planning_txns',
13184: p_error_text => SUBSTRB(SQLERRM,1,240));
13185: raise;
13186: END call_add_planning_txns;

Line 13465: pa_debug.debug('PA_TASK_PUB1.UPDATE_TASK_DET_SCH_INFO begin');

13461:
13462: BEGIN
13463:
13464: IF (p_debug_mode = 'Y') THEN
13465: pa_debug.debug('PA_TASK_PUB1.UPDATE_TASK_DET_SCH_INFO begin');
13466: END IF;
13467:
13468: IF (p_commit = FND_API.G_TRUE) THEN
13469: savepoint UPDATE_task_det_sch;

Line 13475: pa_debug.write(x_Module=>'PA_PROGRESS_PUB.UPDATE_TASK_DET_SCH_INFO', x_Msg => 'PA_TASK_PUB1.UPDATE_TASK_DET_SCH_INFO Start : Passed Parameters :', x_Log_Level=> 3);

13471:
13472: l_debug_mode := NVL(FND_PROFILE.value_specific('PA_DEBUG_MODE',fnd_global.user_id,fnd_global.login_id,275,null,null), 'N');
13473:
13474: IF l_debug_mode = 'Y' THEN
13475: pa_debug.write(x_Module=>'PA_PROGRESS_PUB.UPDATE_TASK_DET_SCH_INFO', x_Msg => 'PA_TASK_PUB1.UPDATE_TASK_DET_SCH_INFO Start : Passed Parameters :', x_Log_Level=> 3);
13476: pa_debug.write(x_Module=>'PA_PROGRESS_PUB.UPDATE_TASK_DET_SCH_INFO', x_Msg => 'p_calling_module='||p_calling_module, x_Log_Level=> 3);
13477: pa_debug.write(x_Module=>'PA_PROGRESS_PUB.UPDATE_TASK_DET_SCH_INFO', x_Msg => 'p_task_ver_id='||p_task_ver_id, x_Log_Level=> 3);
13478: pa_debug.write(x_Module=>'PA_PROGRESS_PUB.UPDATE_TASK_DET_SCH_INFO', x_Msg => 'p_project_id='||p_project_id, x_Log_Level=> 3);
13479: pa_debug.write(x_Module=>'PA_PROGRESS_PUB.UPDATE_TASK_DET_SCH_INFO', x_Msg => 'p_planned_effort='||p_planned_effort, x_Log_Level=> 3);

Line 13769: fnd_msg_pub.add_exc_msg(p_pkg_name => 'PA_TASK_PUB1',

13765: );
13766: END IF;
13767: EXCEPTION
13768: WHEN OTHERS THEN
13769: fnd_msg_pub.add_exc_msg(p_pkg_name => 'PA_TASK_PUB1',
13770: p_procedure_name => 'update_task_det_sch_info',
13771: p_error_text => SUBSTRB('pa_fp_planning_transaction_pub.update_planning_transactions:'||SQLERRM,1,240));
13772: RAISE FND_API.G_EXC_ERROR;
13773: END;

Line 14459: pa_debug.write(x_Module=>'PA_TASK_PUB1.UPDATE_TASK_DET_SCH_INFO', x_Msg => 'Entered For Assignments', x_Log_Level=> 3);

14455:
14456: -- Call rollup API only is there is a working progress for the given task_version and
14457: -- structure_version. The as_of_date will then be the max(as_of_date() of the working progress.
14458: IF l_debug_mode = 'Y' THEN
14459: pa_debug.write(x_Module=>'PA_TASK_PUB1.UPDATE_TASK_DET_SCH_INFO', x_Msg => 'Entered For Assignments', x_Log_Level=> 3);
14460: END IF;
14461:
14462: --bug 4105720, get the task id
14463: OPEN c_proj_element_id;

Line 14473: pa_debug.write(x_Module=>'PA_TASK_PUB1.UPDATE_TASK_DET_SCH_INFO', x_Msg => 'l_task_id '||l_task_id, x_Log_Level=> 3);

14469: FETCH cur_progress_exists INTO l_progress_exists;
14470: CLOSE cur_progress_exists;
14471:
14472: IF l_debug_mode = 'Y' THEN
14473: pa_debug.write(x_Module=>'PA_TASK_PUB1.UPDATE_TASK_DET_SCH_INFO', x_Msg => 'l_task_id '||l_task_id, x_Log_Level=> 3);
14474: pa_debug.write(x_Module=>'PA_TASK_PUB1.UPDATE_TASK_DET_SCH_INFO', x_Msg => 'l_progress_exists '||l_progress_exists, x_Log_Level=> 3);
14475: END IF;
14476:
14477: IF NVL(l_progress_exists, 'N') = 'Y' THEN -- Bug 3976633

Line 14474: pa_debug.write(x_Module=>'PA_TASK_PUB1.UPDATE_TASK_DET_SCH_INFO', x_Msg => 'l_progress_exists '||l_progress_exists, x_Log_Level=> 3);

14470: CLOSE cur_progress_exists;
14471:
14472: IF l_debug_mode = 'Y' THEN
14473: pa_debug.write(x_Module=>'PA_TASK_PUB1.UPDATE_TASK_DET_SCH_INFO', x_Msg => 'l_task_id '||l_task_id, x_Log_Level=> 3);
14474: pa_debug.write(x_Module=>'PA_TASK_PUB1.UPDATE_TASK_DET_SCH_INFO', x_Msg => 'l_progress_exists '||l_progress_exists, x_Log_Level=> 3);
14475: END IF;
14476:
14477: IF NVL(l_progress_exists, 'N') = 'Y' THEN -- Bug 3976633
14478:

Line 14496: pa_debug.write(x_Module=>'PA_TASK_PUB1.UPDATE_TASK_DET_SCH_INFO', x_Msg => 'Calling Rollup For Assignments', x_Log_Level=> 3);

14492: FETCH c_proj_element_id INTO l_task_id;
14493: CLOSE c_proj_element_id;*/
14494:
14495: IF l_debug_mode = 'Y' THEN
14496: pa_debug.write(x_Module=>'PA_TASK_PUB1.UPDATE_TASK_DET_SCH_INFO', x_Msg => 'Calling Rollup For Assignments', x_Log_Level=> 3);
14497: pa_debug.write(x_Module=>'PA_TASK_PUB1.UPDATE_TASK_DET_SCH_INFO', x_Msg => 'l_task_id='||l_task_id, x_Log_Level=> 3);
14498: pa_debug.write(x_Module=>'PA_TASK_PUB1.UPDATE_TASK_DET_SCH_INFO', x_Msg => 'p_task_ver_id='||p_task_ver_id, x_Log_Level=> 3);
14499: pa_debug.write(x_Module=>'PA_TASK_PUB1.UPDATE_TASK_DET_SCH_INFO', x_Msg => 'l_rollup_method='||l_rollup_method, x_Log_Level=> 3);
14500: pa_debug.write(x_Module=>'PA_TASK_PUB1.UPDATE_TASK_DET_SCH_INFO', x_Msg => 'l_rollup_as_of_date='||l_rollup_as_of_date, x_Log_Level=> 3);

Line 14497: pa_debug.write(x_Module=>'PA_TASK_PUB1.UPDATE_TASK_DET_SCH_INFO', x_Msg => 'l_task_id='||l_task_id, x_Log_Level=> 3);

14493: CLOSE c_proj_element_id;*/
14494:
14495: IF l_debug_mode = 'Y' THEN
14496: pa_debug.write(x_Module=>'PA_TASK_PUB1.UPDATE_TASK_DET_SCH_INFO', x_Msg => 'Calling Rollup For Assignments', x_Log_Level=> 3);
14497: pa_debug.write(x_Module=>'PA_TASK_PUB1.UPDATE_TASK_DET_SCH_INFO', x_Msg => 'l_task_id='||l_task_id, x_Log_Level=> 3);
14498: pa_debug.write(x_Module=>'PA_TASK_PUB1.UPDATE_TASK_DET_SCH_INFO', x_Msg => 'p_task_ver_id='||p_task_ver_id, x_Log_Level=> 3);
14499: pa_debug.write(x_Module=>'PA_TASK_PUB1.UPDATE_TASK_DET_SCH_INFO', x_Msg => 'l_rollup_method='||l_rollup_method, x_Log_Level=> 3);
14500: pa_debug.write(x_Module=>'PA_TASK_PUB1.UPDATE_TASK_DET_SCH_INFO', x_Msg => 'l_rollup_as_of_date='||l_rollup_as_of_date, x_Log_Level=> 3);
14501: pa_debug.write(x_Module=>'PA_TASK_PUB1.UPDATE_TASK_DET_SCH_INFO', x_Msg => 'l_rollup_as_of_date='||l_rollup_as_of_date, x_Log_Level=> 3);

Line 14498: pa_debug.write(x_Module=>'PA_TASK_PUB1.UPDATE_TASK_DET_SCH_INFO', x_Msg => 'p_task_ver_id='||p_task_ver_id, x_Log_Level=> 3);

14494:
14495: IF l_debug_mode = 'Y' THEN
14496: pa_debug.write(x_Module=>'PA_TASK_PUB1.UPDATE_TASK_DET_SCH_INFO', x_Msg => 'Calling Rollup For Assignments', x_Log_Level=> 3);
14497: pa_debug.write(x_Module=>'PA_TASK_PUB1.UPDATE_TASK_DET_SCH_INFO', x_Msg => 'l_task_id='||l_task_id, x_Log_Level=> 3);
14498: pa_debug.write(x_Module=>'PA_TASK_PUB1.UPDATE_TASK_DET_SCH_INFO', x_Msg => 'p_task_ver_id='||p_task_ver_id, x_Log_Level=> 3);
14499: pa_debug.write(x_Module=>'PA_TASK_PUB1.UPDATE_TASK_DET_SCH_INFO', x_Msg => 'l_rollup_method='||l_rollup_method, x_Log_Level=> 3);
14500: pa_debug.write(x_Module=>'PA_TASK_PUB1.UPDATE_TASK_DET_SCH_INFO', x_Msg => 'l_rollup_as_of_date='||l_rollup_as_of_date, x_Log_Level=> 3);
14501: pa_debug.write(x_Module=>'PA_TASK_PUB1.UPDATE_TASK_DET_SCH_INFO', x_Msg => 'l_rollup_as_of_date='||l_rollup_as_of_date, x_Log_Level=> 3);
14502: END IF;

Line 14499: pa_debug.write(x_Module=>'PA_TASK_PUB1.UPDATE_TASK_DET_SCH_INFO', x_Msg => 'l_rollup_method='||l_rollup_method, x_Log_Level=> 3);

14495: IF l_debug_mode = 'Y' THEN
14496: pa_debug.write(x_Module=>'PA_TASK_PUB1.UPDATE_TASK_DET_SCH_INFO', x_Msg => 'Calling Rollup For Assignments', x_Log_Level=> 3);
14497: pa_debug.write(x_Module=>'PA_TASK_PUB1.UPDATE_TASK_DET_SCH_INFO', x_Msg => 'l_task_id='||l_task_id, x_Log_Level=> 3);
14498: pa_debug.write(x_Module=>'PA_TASK_PUB1.UPDATE_TASK_DET_SCH_INFO', x_Msg => 'p_task_ver_id='||p_task_ver_id, x_Log_Level=> 3);
14499: pa_debug.write(x_Module=>'PA_TASK_PUB1.UPDATE_TASK_DET_SCH_INFO', x_Msg => 'l_rollup_method='||l_rollup_method, x_Log_Level=> 3);
14500: pa_debug.write(x_Module=>'PA_TASK_PUB1.UPDATE_TASK_DET_SCH_INFO', x_Msg => 'l_rollup_as_of_date='||l_rollup_as_of_date, x_Log_Level=> 3);
14501: pa_debug.write(x_Module=>'PA_TASK_PUB1.UPDATE_TASK_DET_SCH_INFO', x_Msg => 'l_rollup_as_of_date='||l_rollup_as_of_date, x_Log_Level=> 3);
14502: END IF;
14503: -- 4591321 : Always call populate_pji_tab_for_plan

Line 14500: pa_debug.write(x_Module=>'PA_TASK_PUB1.UPDATE_TASK_DET_SCH_INFO', x_Msg => 'l_rollup_as_of_date='||l_rollup_as_of_date, x_Log_Level=> 3);

14496: pa_debug.write(x_Module=>'PA_TASK_PUB1.UPDATE_TASK_DET_SCH_INFO', x_Msg => 'Calling Rollup For Assignments', x_Log_Level=> 3);
14497: pa_debug.write(x_Module=>'PA_TASK_PUB1.UPDATE_TASK_DET_SCH_INFO', x_Msg => 'l_task_id='||l_task_id, x_Log_Level=> 3);
14498: pa_debug.write(x_Module=>'PA_TASK_PUB1.UPDATE_TASK_DET_SCH_INFO', x_Msg => 'p_task_ver_id='||p_task_ver_id, x_Log_Level=> 3);
14499: pa_debug.write(x_Module=>'PA_TASK_PUB1.UPDATE_TASK_DET_SCH_INFO', x_Msg => 'l_rollup_method='||l_rollup_method, x_Log_Level=> 3);
14500: pa_debug.write(x_Module=>'PA_TASK_PUB1.UPDATE_TASK_DET_SCH_INFO', x_Msg => 'l_rollup_as_of_date='||l_rollup_as_of_date, x_Log_Level=> 3);
14501: pa_debug.write(x_Module=>'PA_TASK_PUB1.UPDATE_TASK_DET_SCH_INFO', x_Msg => 'l_rollup_as_of_date='||l_rollup_as_of_date, x_Log_Level=> 3);
14502: END IF;
14503: -- 4591321 : Always call populate_pji_tab_for_plan
14504:

Line 14501: pa_debug.write(x_Module=>'PA_TASK_PUB1.UPDATE_TASK_DET_SCH_INFO', x_Msg => 'l_rollup_as_of_date='||l_rollup_as_of_date, x_Log_Level=> 3);

14497: pa_debug.write(x_Module=>'PA_TASK_PUB1.UPDATE_TASK_DET_SCH_INFO', x_Msg => 'l_task_id='||l_task_id, x_Log_Level=> 3);
14498: pa_debug.write(x_Module=>'PA_TASK_PUB1.UPDATE_TASK_DET_SCH_INFO', x_Msg => 'p_task_ver_id='||p_task_ver_id, x_Log_Level=> 3);
14499: pa_debug.write(x_Module=>'PA_TASK_PUB1.UPDATE_TASK_DET_SCH_INFO', x_Msg => 'l_rollup_method='||l_rollup_method, x_Log_Level=> 3);
14500: pa_debug.write(x_Module=>'PA_TASK_PUB1.UPDATE_TASK_DET_SCH_INFO', x_Msg => 'l_rollup_as_of_date='||l_rollup_as_of_date, x_Log_Level=> 3);
14501: pa_debug.write(x_Module=>'PA_TASK_PUB1.UPDATE_TASK_DET_SCH_INFO', x_Msg => 'l_rollup_as_of_date='||l_rollup_as_of_date, x_Log_Level=> 3);
14502: END IF;
14503: -- 4591321 : Always call populate_pji_tab_for_plan
14504:
14505: pa_progress_pub.populate_pji_tab_for_plan(

Line 14583: fnd_msg_pub.add_exc_msg(p_pkg_name => 'PA_TASK_PUB1',

14579: END IF;
14580: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
14581: x_msg_count := FND_MSG_PUB.count_msg;
14582: --put message
14583: fnd_msg_pub.add_exc_msg(p_pkg_name => 'PA_TASK_PUB1',
14584: p_procedure_name => 'update_task_det_sch_info',
14585: p_error_text => SUBSTRB(SQLERRM,1,240));
14586: RAISE;
14587:

Line 14735: pa_debug.init_err_stack ('PA_TASK_PUB1.COPY_TASKS_IN_BULK');

14731: SELECT pm_product_code
14732: FROM PA_PROJECTS_ALL
14733: WHERE project_id = c_project_id;
14734: BEGIN
14735: pa_debug.init_err_stack ('PA_TASK_PUB1.COPY_TASKS_IN_BULK');
14736: x_return_status := FND_API.G_RET_STS_SUCCESS;
14737: IF (p_debug_mode = 'Y') THEN
14738: pa_debug.debug('PA_TASK_PUB1.COPY_TASKS_IN_BULK begin');
14739: END IF;

Line 14738: pa_debug.debug('PA_TASK_PUB1.COPY_TASKS_IN_BULK begin');

14734: BEGIN
14735: pa_debug.init_err_stack ('PA_TASK_PUB1.COPY_TASKS_IN_BULK');
14736: x_return_status := FND_API.G_RET_STS_SUCCESS;
14737: IF (p_debug_mode = 'Y') THEN
14738: pa_debug.debug('PA_TASK_PUB1.COPY_TASKS_IN_BULK begin');
14739: END IF;
14740:
14741: IF (p_commit = FND_API.G_TRUE) THEN
14742: savepoint copy_tasks_in_bulk;

Line 14997: PA_TASK_PUB1.Copy_Task(

14993:
14994:
14995: IF nvl(p_src_task_version_id_tbl.LAST,0)>0 THEN
14996: FOR i IN p_src_task_version_id_tbl.FIRST..p_src_task_version_id_tbl.LAST LOOP
14997: PA_TASK_PUB1.Copy_Task(
14998: p_init_msg_list => FND_API.G_FALSE,
14999: p_src_project_id => p_src_project_id,
15000: p_src_project_name => p_src_project_name,
15001: p_src_structure_id => p_src_structure_id ,

Line 15067: fnd_msg_pub.add_exc_msg(p_pkg_name => 'PA_TASK_PUB1',

15063: if p_commit = FND_API.G_TRUE then
15064: rollback to Copy_Tasks_in_bulk;
15065: end if;
15066: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
15067: fnd_msg_pub.add_exc_msg(p_pkg_name => 'PA_TASK_PUB1',
15068: p_procedure_name => 'COPY_TASKS_IN_BULK',
15069: p_error_text => SUBSTRB(SQLERRM,1,240));
15070: when OTHERS then
15071: if p_commit = FND_API.G_TRUE then

Line 15075: fnd_msg_pub.add_exc_msg(p_pkg_name => 'PA_TASK_PUB1',

15071: if p_commit = FND_API.G_TRUE then
15072: rollback to Copy_Tasks_in_bulk;
15073: end if;
15074: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
15075: fnd_msg_pub.add_exc_msg(p_pkg_name => 'PA_TASK_PUB1',
15076: p_procedure_name => 'COPY_TASKS_IN_BULK',
15077: p_error_text => SUBSTRB(SQLERRM,1,240));
15078: raise;
15079:

Line 15211: pa_debug.init_err_stack ('PA_TASK_PUB1.MOVE_TASK_VERSIONS_IN_BULK');

15207:
15208: /*4269830 : Performance Enhancements : End*/
15209:
15210: BEGIN
15211: pa_debug.init_err_stack ('PA_TASK_PUB1.MOVE_TASK_VERSIONS_IN_BULK');
15212:
15213: x_return_status := FND_API.G_RET_STS_SUCCESS ;
15214:
15215: IF (p_debug_mode = 'Y') THEN

Line 15216: pa_debug.debug('PA_TASK_PUB1.MOVE_TASK_VERSIONS_IN_BULK begin');

15212:
15213: x_return_status := FND_API.G_RET_STS_SUCCESS ;
15214:
15215: IF (p_debug_mode = 'Y') THEN
15216: pa_debug.debug('PA_TASK_PUB1.MOVE_TASK_VERSIONS_IN_BULK begin');
15217: END IF;
15218:
15219: IF (p_commit = FND_API.G_TRUE) THEN
15220: savepoint MOVE_TASK_VERSIONS_IN_BULK ;

Line 15341: PA_TASK_PUB1.Move_Task_Version(

15337: ref_task_temp_version_id := p_ref_task_version_id; -- Bug 6628382
15338:
15339: IF nvl(p_task_version_id_tbl.LAST,0)>0 THEN
15340: FOR i IN p_task_version_id_tbl.FIRST..p_task_version_id_tbl.LAST LOOP
15341: PA_TASK_PUB1.Move_Task_Version(
15342: p_init_msg_list => FND_API.G_FALSE,
15343: p_structure_version_id => p_structure_version_id,
15344: p_task_version_id => p_task_version_id_tbl(i),
15345: p_ref_task_version_id => ref_task_temp_version_id, --p_ref_task_version_id, -- Bug 6628382

Line 15406: fnd_msg_pub.add_exc_msg(p_pkg_name => 'PA_TASK_PUB1',

15402: if p_commit = FND_API.G_TRUE then
15403: rollback to MOVE_TASK_VERSIONS_IN_BULK;
15404: end if;
15405: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
15406: fnd_msg_pub.add_exc_msg(p_pkg_name => 'PA_TASK_PUB1',
15407: p_procedure_name => 'MOVE_TASK_VERSIONS_IN_BULK',
15408: p_error_text => SUBSTRB(SQLERRM,1,240));
15409: when OTHERS then
15410: if p_commit = FND_API.G_TRUE then

Line 15414: fnd_msg_pub.add_exc_msg(p_pkg_name => 'PA_TASK_PUB1',

15410: if p_commit = FND_API.G_TRUE then
15411: rollback to MOVE_TASK_VERSIONS_IN_BULK;
15412: end if;
15413: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
15414: fnd_msg_pub.add_exc_msg(p_pkg_name => 'PA_TASK_PUB1',
15415: p_procedure_name => 'MOVE_TASK_VERSIONS_IN_BULK',
15416: p_error_text => SUBSTRB(SQLERRM,1,240));
15417: raise;
15418: END MOVE_TASK_VERSIONS_IN_BULK ;

Line 15495: pa_debug.init_err_stack ('PA_TASK_PUB1.Update_Task_All_Info');

15491: l_data VARCHAR2(250);
15492: l_msg_index_out NUMBER;
15493:
15494: BEGIN
15495: pa_debug.init_err_stack ('PA_TASK_PUB1.Update_Task_All_Info');
15496:
15497: IF (p_debug_mode = 'Y') THEN
15498: pa_debug.debug('PA_TASK_PUB1.Update_Task_All_Info begin');
15499: END IF;

Line 15498: pa_debug.debug('PA_TASK_PUB1.Update_Task_All_Info begin');

15494: BEGIN
15495: pa_debug.init_err_stack ('PA_TASK_PUB1.Update_Task_All_Info');
15496:
15497: IF (p_debug_mode = 'Y') THEN
15498: pa_debug.debug('PA_TASK_PUB1.Update_Task_All_Info begin');
15499: END IF;
15500:
15501: IF (p_commit = FND_API.G_TRUE) THEN
15502: savepoint update_Task_all_info;

Line 15519: PA_TASK_PUB1.Update_Task

15515: IF nvl(p_task_id_tbl.last,0) >= 1 THEN
15516:
15517: FOR i in p_task_id_tbl.FIRST .. p_task_id_tbl.LAST LOOP
15518:
15519: PA_TASK_PUB1.Update_Task
15520: (
15521: p_task_id => p_task_id_tbl(i)
15522: ,p_task_number => p_task_number_tbl(i)
15523: ,p_task_name => p_task_name_tbl(i)

Line 15562: PA_TASK_PUB1.Update_Schedule_Version

15558: END IF;
15559: raise FND_API.G_EXC_ERROR;
15560: END IF;
15561:
15562: PA_TASK_PUB1.Update_Schedule_Version
15563: (
15564: p_scheduled_start_date => p_scheduled_start_date_tbl(i)
15565: ,p_scheduled_end_date => p_scheduled_end_date_tbl(i)
15566: ,p_record_version_number => p_sch_rec_ver_num_tbl(i)

Line 15599: PA_TASK_PUB1.update_task_det_sch_info

15595: END IF;
15596: raise FND_API.G_EXC_ERROR;
15597: END IF;
15598:
15599: PA_TASK_PUB1.update_task_det_sch_info
15600: (
15601: p_task_ver_id => p_task_version_id_tbl(i)
15602: ,p_percent_complete => p_percent_complete_tbl(i)
15603: ,p_ETC_effort => p_ETC_effort_tbl(i)

Line 15632: PA_TASK_PUB1.Update_Task_Weighting

15628: END IF;
15629:
15630: IF p_task_weight_method = 'MANUAL' THEN
15631:
15632: PA_TASK_PUB1.Update_Task_Weighting
15633: (
15634: p_object_relationship_id => p_object_relationship_id_tbl(i)
15635: ,p_weighting_percentage => p_weighting_percentage_tbl(i)
15636: ,p_record_version_number => p_obj_rec_ver_num_tbl(i)

Line 15669: pa_debug.debug('PA_TASK_PUB1.Update_Task_All_Info END');

15665: COMMIT;
15666: END IF;
15667:
15668: IF (p_debug_mode = 'Y') THEN
15669: pa_debug.debug('PA_TASK_PUB1.Update_Task_All_Info END');
15670: END IF;
15671:
15672: EXCEPTION
15673: when FND_API.G_EXC_ERROR then

Line 15683: fnd_msg_pub.add_exc_msg(p_pkg_name => 'PA_TASK_PUB1',

15679: if p_commit = FND_API.G_TRUE then
15680: rollback to update_Task_all_info;
15681: end if;
15682: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
15683: fnd_msg_pub.add_exc_msg(p_pkg_name => 'PA_TASK_PUB1',
15684: p_procedure_name => 'Update_Task_All_Info',
15685: p_error_text => SUBSTRB(SQLERRM,1,240));
15686: when OTHERS then
15687: if p_commit = FND_API.G_TRUE then

Line 15691: fnd_msg_pub.add_exc_msg(p_pkg_name => 'PA_TASK_PUB1',

15687: if p_commit = FND_API.G_TRUE then
15688: rollback to update_Task_all_info;
15689: end if;
15690: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
15691: fnd_msg_pub.add_exc_msg(p_pkg_name => 'PA_TASK_PUB1',
15692: p_procedure_name => 'Update_Task_All_Info',
15693: p_error_text => SUBSTRB(SQLERRM,1,240));
15694: raise;
15695:

Line 15716: l_module_name VARCHAR2(100):= 'PA_TASK_PUB1.CANCEL_TASK';

15712: ,x_msg_data OUT NOCOPY VARCHAR2 --File.Sql.39 bug 4440895
15713: )
15714: IS
15715: l_debug_mode VARCHAR2(1);
15716: l_module_name VARCHAR2(100):= 'PA_TASK_PUB1.CANCEL_TASK';
15717: l_error_message_code VARCHAR2(32);
15718:
15719: -- 4533534 : Included join of pa_proj_elem_ver_structure too
15720: CURSOR c_get_all_task_versions(c_task_id NUMBER, c_project_id NUMBER) IS

Line 15937: fnd_msg_pub.add_exc_msg(p_pkg_name => 'PA_TASK_PUB1',

15933: x_msg_count := fnd_msg_pub.count_msg;
15934: ROLLBACK to CANCEL_TASK_SP;
15935: when FND_API.G_EXC_UNEXPECTED_ERROR then
15936: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
15937: fnd_msg_pub.add_exc_msg(p_pkg_name => 'PA_TASK_PUB1',
15938: p_procedure_name => 'CANCEL_TASK',
15939: p_error_text => SUBSTRB(SQLERRM,1,240));
15940: x_msg_count := fnd_msg_pub.count_msg;
15941: ROLLBACK to CANCEL_TASK_SP;

Line 15944: fnd_msg_pub.add_exc_msg(p_pkg_name => 'PA_TASK_PUB1',

15940: x_msg_count := fnd_msg_pub.count_msg;
15941: ROLLBACK to CANCEL_TASK_SP;
15942: when OTHERS then
15943: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
15944: fnd_msg_pub.add_exc_msg(p_pkg_name => 'PA_TASK_PUB1',
15945: p_procedure_name => 'CANCEL_TASK',
15946: p_error_text => SUBSTRB(SQLERRM,1,240));
15947: x_msg_count := fnd_msg_pub.count_msg;
15948: ROLLBACK to CANCEL_TASK_SP;

Line 16024: pa_debug.init_err_stack ('PA_TASK_PUB1.INDENT_MULTI_TASK_VERSION');

16020: l_rec_task_attr l_cur_task_attr%rowtype;
16021:
16022: BEGIN
16023:
16024: pa_debug.init_err_stack ('PA_TASK_PUB1.INDENT_MULTI_TASK_VERSION');
16025:
16026: IF (p_debug_mode = 'Y') THEN
16027: pa_debug.debug('PA_TASK_PUB1.INDENT_MULTI_TASK_VERSION BEGIN');
16028: END IF;

Line 16027: pa_debug.debug('PA_TASK_PUB1.INDENT_MULTI_TASK_VERSION BEGIN');

16023:
16024: pa_debug.init_err_stack ('PA_TASK_PUB1.INDENT_MULTI_TASK_VERSION');
16025:
16026: IF (p_debug_mode = 'Y') THEN
16027: pa_debug.debug('PA_TASK_PUB1.INDENT_MULTI_TASK_VERSION BEGIN');
16028: END IF;
16029:
16030: IF (p_commit = FND_API.G_TRUE) THEN
16031: savepoint indent_multi_task_version;

Line 16078: -- Call the API: PA_TASK_PUB1.INDENT_TASK_VERSION_BULK().

16074: loop
16075: -- Clear the message stack.
16076: FND_MSG_PUB.initialize;
16077:
16078: -- Call the API: PA_TASK_PUB1.INDENT_TASK_VERSION_BULK().
16079: PA_TASK_PUB1.INDENT_TASK_VERSION_BULK
16080: (p_api_version => p_api_version
16081: , p_init_msg_list => p_init_msg_list
16082: , p_commit => p_commit

Line 16079: PA_TASK_PUB1.INDENT_TASK_VERSION_BULK

16075: -- Clear the message stack.
16076: FND_MSG_PUB.initialize;
16077:
16078: -- Call the API: PA_TASK_PUB1.INDENT_TASK_VERSION_BULK().
16079: PA_TASK_PUB1.INDENT_TASK_VERSION_BULK
16080: (p_api_version => p_api_version
16081: , p_init_msg_list => p_init_msg_list
16082: , p_commit => p_commit
16083: , p_validate_only => p_validate_only

Line 16154: pa_debug.debug('PA_TASK_PUB1.INDENT_MULTI_TASK_VERSION END');

16150: COMMIT;
16151: END IF;
16152:
16153: IF (p_debug_mode = 'Y') THEN
16154: pa_debug.debug('PA_TASK_PUB1.INDENT_MULTI_TASK_VERSION END');
16155: END IF;
16156:
16157: EXCEPTION
16158:

Line 16170: fnd_msg_pub.add_exc_msg(p_pkg_name => 'PA_TASK_PUB1',

16166: if p_commit = FND_API.G_TRUE then
16167: rollback to indent_multi_task_version;
16168: end if;
16169: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
16170: fnd_msg_pub.add_exc_msg(p_pkg_name => 'PA_TASK_PUB1',
16171: p_procedure_name => 'INDENT_MULTI_TASK_VERSION',
16172: p_error_text => SUBSTRB(SQLERRM,1,240));
16173: when OTHERS then
16174: if p_commit = FND_API.G_TRUE then

Line 16178: fnd_msg_pub.add_exc_msg(p_pkg_name => 'PA_TASK_PUB1',

16174: if p_commit = FND_API.G_TRUE then
16175: rollback to indent_multi_task_version;
16176: end if;
16177: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
16178: fnd_msg_pub.add_exc_msg(p_pkg_name => 'PA_TASK_PUB1',
16179: p_procedure_name => 'INDENT_MULTI_TASK_VERSION',
16180: p_error_text => SUBSTRB(SQLERRM,1,240));
16181:
16182: raise;

Line 16256: pa_debug.init_err_stack ('PA_TASK_PUB1.OUTDENT_MULTI_TASK_VERSION');

16252: l_rec_task_attr l_cur_task_attr%rowtype;
16253:
16254: BEGIN
16255:
16256: pa_debug.init_err_stack ('PA_TASK_PUB1.OUTDENT_MULTI_TASK_VERSION');
16257:
16258: IF (p_debug_mode = 'Y') THEN
16259: pa_debug.debug('PA_TASK_PUB1.OUTDENT_MULTI_TASK_VERSION BEGIN');
16260: END IF;

Line 16259: pa_debug.debug('PA_TASK_PUB1.OUTDENT_MULTI_TASK_VERSION BEGIN');

16255:
16256: pa_debug.init_err_stack ('PA_TASK_PUB1.OUTDENT_MULTI_TASK_VERSION');
16257:
16258: IF (p_debug_mode = 'Y') THEN
16259: pa_debug.debug('PA_TASK_PUB1.OUTDENT_MULTI_TASK_VERSION BEGIN');
16260: END IF;
16261:
16262: IF (p_commit = FND_API.G_TRUE) THEN
16263: savepoint outdent_multi_task_version;

Line 16310: -- Call the API: PA_TASK_PUB1.OUTDENT_TASK_VERSION_BULK().

16306: loop
16307: -- Clear the message stack.
16308: FND_MSG_PUB.initialize;
16309:
16310: -- Call the API: PA_TASK_PUB1.OUTDENT_TASK_VERSION_BULK().
16311: PA_TASK_PUB1.OUTDENT_TASK_VERSION_BULK
16312: (p_api_version => p_api_version
16313: , p_init_msg_list => p_init_msg_list
16314: , p_commit => p_commit

Line 16311: PA_TASK_PUB1.OUTDENT_TASK_VERSION_BULK

16307: -- Clear the message stack.
16308: FND_MSG_PUB.initialize;
16309:
16310: -- Call the API: PA_TASK_PUB1.OUTDENT_TASK_VERSION_BULK().
16311: PA_TASK_PUB1.OUTDENT_TASK_VERSION_BULK
16312: (p_api_version => p_api_version
16313: , p_init_msg_list => p_init_msg_list
16314: , p_commit => p_commit
16315: , p_validate_only => p_validate_only

Line 16380: pa_debug.debug('PA_TASK_PUB1.OUTDENT_MULTI_TASK_VERSION END');

16376: COMMIT;
16377: END IF;
16378:
16379: IF (p_debug_mode = 'Y') THEN
16380: pa_debug.debug('PA_TASK_PUB1.OUTDENT_MULTI_TASK_VERSION END');
16381: END IF;
16382:
16383: EXCEPTION
16384:

Line 16396: fnd_msg_pub.add_exc_msg(p_pkg_name => 'PA_TASK_PUB1',

16392: if p_commit = FND_API.G_TRUE then
16393: rollback to outdent_multi_task_version;
16394: end if;
16395: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
16396: fnd_msg_pub.add_exc_msg(p_pkg_name => 'PA_TASK_PUB1',
16397: p_procedure_name => 'OUTDENT_MULTI_TASK_VERSION',
16398: p_error_text => SUBSTRB(SQLERRM,1,240));
16399: when OTHERS then
16400: if p_commit = FND_API.G_TRUE then

Line 16404: fnd_msg_pub.add_exc_msg(p_pkg_name => 'PA_TASK_PUB1',

16400: if p_commit = FND_API.G_TRUE then
16401: rollback to outdent_multi_task_version;
16402: end if;
16403: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
16404: fnd_msg_pub.add_exc_msg(p_pkg_name => 'PA_TASK_PUB1',
16405: p_procedure_name => 'OUTDENT_MULTI_TASK_VERSION',
16406: p_error_text => SUBSTRB(SQLERRM,1,240));
16407:
16408: raise;

Line 16414: END PA_TASK_PUB1;

16410: END OUTDENT_MULTI_TASK_VERSION;
16411:
16412: -- End of Bug Fix 5593736.
16413:
16414: END PA_TASK_PUB1;