DBA Data[Home] [Help]

APPS.JTF_TASKS_PUB dependencies on FND_MSG_PUB

Line 122: fnd_msg_pub.initialize;

118: RAISE fnd_api.g_exc_unexpected_error;
119: END IF;
120:
121: IF fnd_api.to_boolean(p_init_msg_list) THEN
122: fnd_msg_pub.initialize;
123: END IF;
124:
125: -- call new version, passing defaults for new functionality
126: -- Remove the fix of Bug 2152549: call create_task_b which is non-overloading procedure

Line 243: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);

239: IF fnd_api.to_boolean(p_commit) THEN
240: COMMIT WORK;
241: END IF;
242:
243: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);
244: EXCEPTION
245: WHEN fnd_api.g_exc_unexpected_error THEN
246: ROLLBACK TO create_task_pub2;
247: x_return_status := fnd_api.g_ret_sts_unexp_error;

Line 248: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);

244: EXCEPTION
245: WHEN fnd_api.g_exc_unexpected_error THEN
246: ROLLBACK TO create_task_pub2;
247: x_return_status := fnd_api.g_ret_sts_unexp_error;
248: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);
249: WHEN OTHERS THEN
250: ROLLBACK TO create_task_pub2;
251: fnd_message.set_name('JTF', 'JTF_TASK_UNKNOWN_ERROR');
252: fnd_message.set_token('P_TEXT', SQLCODE || SQLERRM);

Line 253: fnd_msg_pub.ADD;

249: WHEN OTHERS THEN
250: ROLLBACK TO create_task_pub2;
251: fnd_message.set_name('JTF', 'JTF_TASK_UNKNOWN_ERROR');
252: fnd_message.set_token('P_TEXT', SQLCODE || SQLERRM);
253: fnd_msg_pub.ADD;
254: x_return_status := fnd_api.g_ret_sts_unexp_error;
255: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);
256: END;
257:

Line 255: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);

251: fnd_message.set_name('JTF', 'JTF_TASK_UNKNOWN_ERROR');
252: fnd_message.set_token('P_TEXT', SQLCODE || SQLERRM);
253: fnd_msg_pub.ADD;
254: x_return_status := fnd_api.g_ret_sts_unexp_error;
255: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);
256: END;
257:
258: -- Overloaded Version for the Simplex Fix.
259: -- new version without table type parameters

Line 379: fnd_msg_pub.initialize;

375: RAISE fnd_api.g_exc_unexpected_error;
376: END IF;
377:
378: IF fnd_api.to_boolean(p_init_msg_list) THEN
379: fnd_msg_pub.initialize;
380: END IF;
381:
382: -- call new version, passing defaults for new functionality
383: create_task(

Line 509: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);

505: IF fnd_api.to_boolean(p_commit) THEN
506: COMMIT WORK;
507: END IF;
508:
509: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);
510: EXCEPTION
511: WHEN fnd_api.g_exc_unexpected_error THEN
512: ROLLBACK TO create_task_pub1;
513: x_return_status := fnd_api.g_ret_sts_unexp_error;

Line 514: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);

510: EXCEPTION
511: WHEN fnd_api.g_exc_unexpected_error THEN
512: ROLLBACK TO create_task_pub1;
513: x_return_status := fnd_api.g_ret_sts_unexp_error;
514: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);
515: WHEN OTHERS THEN
516: ROLLBACK TO create_task_pub1;
517: fnd_message.set_name('JTF', 'JTF_TASK_UNKNOWN_ERROR');
518: fnd_message.set_token('P_TEXT', SQLCODE || SQLERRM);

Line 519: fnd_msg_pub.ADD;

515: WHEN OTHERS THEN
516: ROLLBACK TO create_task_pub1;
517: fnd_message.set_name('JTF', 'JTF_TASK_UNKNOWN_ERROR');
518: fnd_message.set_token('P_TEXT', SQLCODE || SQLERRM);
519: fnd_msg_pub.ADD;
520: x_return_status := fnd_api.g_ret_sts_unexp_error;
521: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);
522: END;
523:

Line 521: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);

517: fnd_message.set_name('JTF', 'JTF_TASK_UNKNOWN_ERROR');
518: fnd_message.set_token('P_TEXT', SQLCODE || SQLERRM);
519: fnd_msg_pub.ADD;
520: x_return_status := fnd_api.g_ret_sts_unexp_error;
521: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);
522: END;
523:
524: -- Overloaded Version for Location Id Enh# 3691788.
525: PROCEDURE create_task(

Line 716: fnd_msg_pub.initialize;

712: RAISE fnd_api.g_exc_unexpected_error;
713: END IF;
714:
715: IF fnd_api.to_boolean(p_init_msg_list) THEN
716: fnd_msg_pub.initialize;
717: END IF;
718:
719: /* Modified by TSINGHAL bug fix Validate task name length 3182170 Start*/
720: l_task_name := check_param_length(p_task_name, 'JTF_TASK_NAME_INVALID_LENGTH', 80);

Line 740: fnd_msg_pub.ADD;

736: END IF;
737:
738: IF l_task_type_id IS NULL THEN
739: fnd_message.set_name('JTF', 'JTF_TASK_MISSING_TASK_TYPE');
740: fnd_msg_pub.ADD;
741: RAISE fnd_api.g_exc_unexpected_error;
742: END IF;
743:
744: -------

Line 763: fnd_msg_pub.ADD;

759: );
760:
761: IF l_task_status_id IS NULL THEN
762: fnd_message.set_name('JTF', 'JTF_TASK_MISSING_TASK_STATUS');
763: fnd_msg_pub.ADD;
764: RAISE fnd_api.g_exc_unexpected_error;
765: END IF;
766:
767: -------

Line 858: fnd_msg_pub.ADD;

854: );
855:
856: IF NOT(x_return_status = fnd_api.g_ret_sts_success) THEN
857: fnd_message.set_name('JTF', 'JTF_TASK_MISSING_OWNER');
858: fnd_msg_pub.ADD;
859: x_return_status := fnd_api.g_ret_sts_unexp_error;
860: RAISE fnd_api.g_exc_unexpected_error;
861: END IF;
862:

Line 865: fnd_msg_pub.ADD;

861: END IF;
862:
863: IF l_owner_id IS NULL THEN
864: fnd_message.set_name('JTF', 'JTF_TASK_OWNER');
865: fnd_msg_pub.ADD;
866: RAISE fnd_api.g_exc_unexpected_error;
867: END IF;
868:
869: IF l_owner_type_code IS NULL THEN

Line 871: fnd_msg_pub.ADD;

867: END IF;
868:
869: IF l_owner_type_code IS NULL THEN
870: fnd_message.set_name('JTF', 'JTF_TASK_OWNER_TYPE_CODE');
871: fnd_msg_pub.ADD;
872: RAISE fnd_api.g_exc_unexpected_error;
873: END IF;
874:
875: -------

Line 1252: fnd_msg_pub.ADD;

1248: -------
1249: IF p_percentage_complete IS NOT NULL THEN
1250: IF p_percentage_complete < 0 OR p_percentage_complete > 100 THEN
1251: fnd_message.set_name('JTF', 'JTF_TASK_INVALID_PCT_COMPLETE');
1252: fnd_msg_pub.ADD;
1253: x_return_status := fnd_api.g_ret_sts_unexp_error;
1254: RAISE fnd_api.g_exc_unexpected_error;
1255: END IF;
1256: END IF;

Line 1756: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);

1752: IF fnd_api.to_boolean(p_commit) THEN
1753: COMMIT WORK;
1754: END IF;
1755:
1756: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);
1757: EXCEPTION
1758: WHEN fnd_api.g_exc_unexpected_error THEN
1759: ROLLBACK TO create_task_pub;
1760: x_return_status := fnd_api.g_ret_sts_unexp_error;

Line 1761: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);

1757: EXCEPTION
1758: WHEN fnd_api.g_exc_unexpected_error THEN
1759: ROLLBACK TO create_task_pub;
1760: x_return_status := fnd_api.g_ret_sts_unexp_error;
1761: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);
1762: WHEN OTHERS THEN
1763: ROLLBACK TO create_task_pub;
1764: fnd_message.set_name('JTF', 'JTF_TASK_UNKNOWN_ERROR');
1765: fnd_message.set_token('P_TEXT', SQLCODE || SQLERRM);

Line 1766: fnd_msg_pub.ADD;

1762: WHEN OTHERS THEN
1763: ROLLBACK TO create_task_pub;
1764: fnd_message.set_name('JTF', 'JTF_TASK_UNKNOWN_ERROR');
1765: fnd_message.set_token('P_TEXT', SQLCODE || SQLERRM);
1766: fnd_msg_pub.ADD;
1767: x_return_status := fnd_api.g_ret_sts_unexp_error;
1768: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);
1769: END;
1770:

Line 1768: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);

1764: fnd_message.set_name('JTF', 'JTF_TASK_UNKNOWN_ERROR');
1765: fnd_message.set_token('P_TEXT', SQLCODE || SQLERRM);
1766: fnd_msg_pub.ADD;
1767: x_return_status := fnd_api.g_ret_sts_unexp_error;
1768: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);
1769: END;
1770:
1771: -- original version including table type parameters
1772: -- Remove the fix of Bug 2152549

Line 1895: fnd_msg_pub.initialize;

1891: RAISE fnd_api.g_exc_unexpected_error;
1892: END IF;
1893:
1894: IF fnd_api.to_boolean(p_init_msg_list) THEN
1895: fnd_msg_pub.initialize;
1896: END IF;
1897:
1898: -- call new version, passing defaults for new functionality
1899: -- Remove the fix of Bug 2152549: call create_task_b which is non-overloading procedure

Line 2028: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);

2024: IF fnd_api.to_boolean(p_commit) THEN
2025: COMMIT WORK;
2026: END IF;
2027:
2028: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);
2029: EXCEPTION
2030: WHEN fnd_api.g_exc_unexpected_error THEN
2031: ROLLBACK TO create_task_pub2;
2032: x_return_status := fnd_api.g_ret_sts_unexp_error;

Line 2033: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);

2029: EXCEPTION
2030: WHEN fnd_api.g_exc_unexpected_error THEN
2031: ROLLBACK TO create_task_pub2;
2032: x_return_status := fnd_api.g_ret_sts_unexp_error;
2033: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);
2034: WHEN OTHERS THEN
2035: ROLLBACK TO create_task_pub2;
2036: fnd_message.set_name('JTF', 'JTF_TASK_UNKNOWN_ERROR');
2037: fnd_message.set_token('P_TEXT', SQLCODE || SQLERRM);

Line 2038: fnd_msg_pub.ADD;

2034: WHEN OTHERS THEN
2035: ROLLBACK TO create_task_pub2;
2036: fnd_message.set_name('JTF', 'JTF_TASK_UNKNOWN_ERROR');
2037: fnd_message.set_token('P_TEXT', SQLCODE || SQLERRM);
2038: fnd_msg_pub.ADD;
2039: x_return_status := fnd_api.g_ret_sts_unexp_error;
2040: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);
2041: END;
2042:

Line 2040: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);

2036: fnd_message.set_name('JTF', 'JTF_TASK_UNKNOWN_ERROR');
2037: fnd_message.set_token('P_TEXT', SQLCODE || SQLERRM);
2038: fnd_msg_pub.ADD;
2039: x_return_status := fnd_api.g_ret_sts_unexp_error;
2040: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);
2041: END;
2042:
2043: -- Old Version
2044: PROCEDURE update_task(

Line 2158: fnd_msg_pub.initialize;

2154: RAISE fnd_api.g_exc_unexpected_error;
2155: END IF;
2156:
2157: IF fnd_api.to_boolean(p_init_msg_list) THEN
2158: fnd_msg_pub.initialize;
2159: END IF;
2160:
2161: update_task
2162: (

Line 2279: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);

2275: IF fnd_api.to_boolean(p_commit) THEN
2276: COMMIT WORK;
2277: END IF;
2278:
2279: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);
2280: EXCEPTION
2281: WHEN fnd_api.g_exc_unexpected_error THEN
2282: ROLLBACK TO update_task_pub1;
2283: x_return_status := fnd_api.g_ret_sts_unexp_error;

Line 2284: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);

2280: EXCEPTION
2281: WHEN fnd_api.g_exc_unexpected_error THEN
2282: ROLLBACK TO update_task_pub1;
2283: x_return_status := fnd_api.g_ret_sts_unexp_error;
2284: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);
2285: WHEN OTHERS THEN
2286: ROLLBACK TO update_task_pub1;
2287: fnd_message.set_name('JTF', 'JTF_TASK_UNKNOWN_ERROR');
2288: fnd_message.set_token('P_TEXT', SQLCODE || SQLERRM);

Line 2289: fnd_msg_pub.ADD;

2285: WHEN OTHERS THEN
2286: ROLLBACK TO update_task_pub1;
2287: fnd_message.set_name('JTF', 'JTF_TASK_UNKNOWN_ERROR');
2288: fnd_message.set_token('P_TEXT', SQLCODE || SQLERRM);
2289: fnd_msg_pub.ADD;
2290: x_return_status := fnd_api.g_ret_sts_unexp_error;
2291: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);
2292: END;
2293:

Line 2291: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);

2287: fnd_message.set_name('JTF', 'JTF_TASK_UNKNOWN_ERROR');
2288: fnd_message.set_token('P_TEXT', SQLCODE || SQLERRM);
2289: fnd_msg_pub.ADD;
2290: x_return_status := fnd_api.g_ret_sts_unexp_error;
2291: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);
2292: END;
2293:
2294: -- Old Version
2295: PROCEDURE update_task(

Line 2411: fnd_msg_pub.initialize;

2407: RAISE fnd_api.g_exc_unexpected_error;
2408: END IF;
2409:
2410: IF fnd_api.to_boolean(p_init_msg_list) THEN
2411: fnd_msg_pub.initialize;
2412: END IF;
2413:
2414: update_task
2415: (

Line 2535: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);

2531: IF fnd_api.to_boolean(p_commit) THEN
2532: COMMIT WORK;
2533: END IF;
2534:
2535: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);
2536: EXCEPTION
2537: WHEN fnd_api.g_exc_unexpected_error THEN
2538: ROLLBACK TO update_task_pub2;
2539: x_return_status := fnd_api.g_ret_sts_unexp_error;

Line 2540: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);

2536: EXCEPTION
2537: WHEN fnd_api.g_exc_unexpected_error THEN
2538: ROLLBACK TO update_task_pub2;
2539: x_return_status := fnd_api.g_ret_sts_unexp_error;
2540: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);
2541: WHEN OTHERS THEN
2542: ROLLBACK TO update_task_pub2;
2543: fnd_message.set_name('JTF', 'JTF_TASK_UNKNOWN_ERROR');
2544: fnd_message.set_token('P_TEXT', SQLCODE || SQLERRM);

Line 2545: fnd_msg_pub.ADD;

2541: WHEN OTHERS THEN
2542: ROLLBACK TO update_task_pub2;
2543: fnd_message.set_name('JTF', 'JTF_TASK_UNKNOWN_ERROR');
2544: fnd_message.set_token('P_TEXT', SQLCODE || SQLERRM);
2545: fnd_msg_pub.ADD;
2546: x_return_status := fnd_api.g_ret_sts_unexp_error;
2547: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);
2548: END;
2549:

Line 2547: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);

2543: fnd_message.set_name('JTF', 'JTF_TASK_UNKNOWN_ERROR');
2544: fnd_message.set_token('P_TEXT', SQLCODE || SQLERRM);
2545: fnd_msg_pub.ADD;
2546: x_return_status := fnd_api.g_ret_sts_unexp_error;
2547: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);
2548: END;
2549:
2550: -- Old version
2551: PROCEDURE update_task(

Line 2670: fnd_msg_pub.initialize;

2666: RAISE fnd_api.g_exc_unexpected_error;
2667: END IF;
2668:
2669: IF fnd_api.to_boolean(p_init_msg_list) THEN
2670: fnd_msg_pub.initialize;
2671: END IF;
2672:
2673: update_task
2674: (

Line 2795: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);

2791: IF fnd_api.to_boolean(p_commit) THEN
2792: COMMIT WORK;
2793: END IF;
2794:
2795: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);
2796: EXCEPTION
2797: WHEN fnd_api.g_exc_unexpected_error THEN
2798: ROLLBACK TO update_task_pub3;
2799: x_return_status := fnd_api.g_ret_sts_unexp_error;

Line 2800: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);

2796: EXCEPTION
2797: WHEN fnd_api.g_exc_unexpected_error THEN
2798: ROLLBACK TO update_task_pub3;
2799: x_return_status := fnd_api.g_ret_sts_unexp_error;
2800: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);
2801: WHEN OTHERS THEN
2802: ROLLBACK TO update_task_pub3;
2803: fnd_message.set_name('JTF', 'JTF_TASK_UNKNOWN_ERROR');
2804: fnd_message.set_token('P_TEXT', SQLCODE || SQLERRM);

Line 2805: fnd_msg_pub.ADD;

2801: WHEN OTHERS THEN
2802: ROLLBACK TO update_task_pub3;
2803: fnd_message.set_name('JTF', 'JTF_TASK_UNKNOWN_ERROR');
2804: fnd_message.set_token('P_TEXT', SQLCODE || SQLERRM);
2805: fnd_msg_pub.ADD;
2806: x_return_status := fnd_api.g_ret_sts_unexp_error;
2807: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);
2808: END;
2809:

Line 2807: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);

2803: fnd_message.set_name('JTF', 'JTF_TASK_UNKNOWN_ERROR');
2804: fnd_message.set_token('P_TEXT', SQLCODE || SQLERRM);
2805: fnd_msg_pub.ADD;
2806: x_return_status := fnd_api.g_ret_sts_unexp_error;
2807: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);
2808: END;
2809:
2810: PROCEDURE update_task(
2811: p_api_version IN NUMBER

Line 3200: fnd_msg_pub.initialize;

3196: RAISE fnd_api.g_exc_unexpected_error;
3197: END IF;
3198:
3199: IF fnd_api.to_boolean(p_init_msg_list) THEN
3200: fnd_msg_pub.initialize;
3201: END IF;
3202:
3203: /* Modified by TSINGHAL bug fix Validate task name length 3182170 Start*/
3204: l_task_name :=

Line 3297: fnd_msg_pub.ADD;

3293: ----- Validate Tasks
3294: -----
3295: IF (l_task_id = fnd_api.g_miss_num AND l_task_number = fnd_api.g_miss_char) THEN
3296: fnd_message.set_name('JTF', 'JTF_TASK_MISSING_TASK');
3297: fnd_msg_pub.ADD;
3298: x_return_status := fnd_api.g_ret_sts_unexp_error;
3299: RAISE fnd_api.g_exc_unexpected_error;
3300: ELSE
3301: SELECT DECODE(l_task_id, fnd_api.g_miss_num, NULL, l_task_id)

Line 3324: fnd_msg_pub.ADD;

3320:
3321: IF l_task_id IS NULL THEN
3322: fnd_message.set_name('JTF', 'JTF_TASK_INVALID_TASK_NUMBER');
3323: fnd_message.set_token('P_TASK_NUMBER', l_task_number);
3324: fnd_msg_pub.ADD;
3325: x_return_status := fnd_api.g_ret_sts_unexp_error;
3326: RAISE fnd_api.g_exc_unexpected_error;
3327: END IF;
3328: END IF;

Line 3335: fnd_msg_pub.ADD;

3331: ----- Task Name
3332: -----
3333: IF l_task_name IS NULL THEN
3334: fnd_message.set_name('JTF', 'JTF_TASK_INVALID_TASK_NAME');
3335: fnd_msg_pub.ADD;
3336: x_return_status := fnd_api.g_ret_sts_unexp_error;
3337: RAISE fnd_api.g_exc_unexpected_error;
3338: END IF;
3339:

Line 3353: fnd_msg_pub.ADD;

3349:
3350: IF c_task_update%NOTFOUND THEN
3351: fnd_message.set_name('JTF', 'JTF_TASK_INVALID_TASK_ID');
3352: fnd_message.set_token('P_TASK_ID', l_task_id);
3353: fnd_msg_pub.ADD;
3354: x_return_status := fnd_api.g_ret_sts_unexp_error;
3355: RAISE fnd_api.g_exc_unexpected_error;
3356: END IF;
3357:

Line 3393: fnd_msg_pub.ADD;

3389: END IF;
3390:
3391: IF l_task_type_id IS NULL THEN
3392: fnd_message.set_name('JTF', 'JTF_TASK_MISSING_TYPE');
3393: fnd_msg_pub.ADD;
3394: RAISE fnd_api.g_exc_unexpected_error;
3395: END IF;
3396:
3397: -------

Line 3456: fnd_msg_pub.ADD;

3452: END IF;
3453:
3454: IF l_task_status_id IS NULL THEN
3455: fnd_message.set_name('JTF', 'JTF_TASK_MISSING_status');
3456: fnd_msg_pub.ADD;
3457: RAISE fnd_api.g_exc_unexpected_error;
3458: END IF;
3459:
3460: --------

Line 3811: fnd_msg_pub.ADD;

3807: -------
3808: IF (p_percentage_complete <> fnd_api.g_miss_num OR p_percentage_complete IS NULL) THEN
3809: IF p_percentage_complete < 0 OR p_percentage_complete > 100 THEN
3810: fnd_message.set_name('JTF', 'JTF_TASK_INVALID_PCT_COMPLETE');
3811: fnd_msg_pub.ADD;
3812: x_return_status := fnd_api.g_ret_sts_unexp_error;
3813: RAISE fnd_api.g_exc_unexpected_error;
3814: END IF;
3815: END IF;

Line 4223: fnd_msg_pub.ADD;

4219: );
4220:
4221: IF NOT(x_return_status = fnd_api.g_ret_sts_success) THEN
4222: fnd_message.set_name('JTF', 'INVALID_NOTIFICATION');
4223: fnd_msg_pub.ADD;
4224: x_return_status := fnd_api.g_ret_sts_unexp_error;
4225: RAISE fnd_api.g_exc_unexpected_error;
4226: END IF;
4227: ELSE

Line 4271: fnd_msg_pub.ADD;

4267: );
4268:
4269: IF NOT(x_return_status = fnd_api.g_ret_sts_success) THEN
4270: fnd_message.set_name('JTF', 'INVALID_ALARM_PARAM');
4271: fnd_msg_pub.ADD;
4272: x_return_status := fnd_api.g_ret_sts_unexp_error;
4273: RAISE fnd_api.g_exc_unexpected_error;
4274: END IF;
4275:

Line 4279: fnd_msg_pub.ADD;

4275:
4276: IF l_alarm_fired_count IS NOT NULL THEN
4277: IF l_alarm_fired_count > l_alarm_count THEN
4278: fnd_message.set_name('JTF', 'INVALID_ALARM_PARAM');
4279: fnd_msg_pub.ADD;
4280: x_return_status := fnd_api.g_ret_sts_unexp_error;
4281: RAISE fnd_api.g_exc_unexpected_error;
4282: END IF;
4283: END IF;

Line 4532: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);

4528: IF fnd_api.to_boolean(p_commit) THEN
4529: COMMIT WORK;
4530: END IF;
4531:
4532: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);
4533: EXCEPTION
4534: WHEN fnd_api.g_exc_unexpected_error THEN
4535: ROLLBACK TO update_task_pub;
4536: x_return_status := fnd_api.g_ret_sts_unexp_error;

Line 4537: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);

4533: EXCEPTION
4534: WHEN fnd_api.g_exc_unexpected_error THEN
4535: ROLLBACK TO update_task_pub;
4536: x_return_status := fnd_api.g_ret_sts_unexp_error;
4537: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);
4538: WHEN NO_DATA_FOUND THEN
4539: ROLLBACK TO update_task_pub;
4540: x_return_status := fnd_api.g_ret_sts_unexp_error;
4541: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);

Line 4541: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);

4537: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);
4538: WHEN NO_DATA_FOUND THEN
4539: ROLLBACK TO update_task_pub;
4540: x_return_status := fnd_api.g_ret_sts_unexp_error;
4541: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);
4542: WHEN OTHERS THEN
4543: fnd_message.set_name('JTF', 'JTF_TASK_UNKNOWN_ERROR');
4544: fnd_message.set_token('P_TEXT', SQLCODE || SQLERRM);
4545: fnd_msg_pub.ADD;

Line 4545: fnd_msg_pub.ADD;

4541: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);
4542: WHEN OTHERS THEN
4543: fnd_message.set_name('JTF', 'JTF_TASK_UNKNOWN_ERROR');
4544: fnd_message.set_token('P_TEXT', SQLCODE || SQLERRM);
4545: fnd_msg_pub.ADD;
4546: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);
4547: ROLLBACK TO update_task_pub;
4548: x_return_status := fnd_api.g_ret_sts_unexp_error;
4549: END;

Line 4546: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);

4542: WHEN OTHERS THEN
4543: fnd_message.set_name('JTF', 'JTF_TASK_UNKNOWN_ERROR');
4544: fnd_message.set_token('P_TEXT', SQLCODE || SQLERRM);
4545: fnd_msg_pub.ADD;
4546: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);
4547: ROLLBACK TO update_task_pub;
4548: x_return_status := fnd_api.g_ret_sts_unexp_error;
4549: END;
4550:

Line 4575: fnd_msg_pub.initialize;

4571: RAISE fnd_api.g_exc_unexpected_error;
4572: END IF;
4573:
4574: IF fnd_api.to_boolean(p_init_msg_list) THEN
4575: fnd_msg_pub.initialize;
4576: END IF;
4577:
4578: delete_task(
4579: p_api_version => 1.0

Line 4602: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);

4598: IF fnd_api.to_boolean(p_commit) THEN
4599: COMMIT WORK;
4600: END IF;
4601:
4602: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);
4603: EXCEPTION
4604: WHEN fnd_api.g_exc_unexpected_error THEN
4605: ROLLBACK TO delete_task_pub2;
4606: x_return_status := fnd_api.g_ret_sts_unexp_error;

Line 4607: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);

4603: EXCEPTION
4604: WHEN fnd_api.g_exc_unexpected_error THEN
4605: ROLLBACK TO delete_task_pub2;
4606: x_return_status := fnd_api.g_ret_sts_unexp_error;
4607: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);
4608: WHEN OTHERS THEN
4609: fnd_message.set_name('JTF', 'JTF_TASK_UNKNOWN_ERROR');
4610: fnd_message.set_token('P_TEXT', SQLCODE || SQLERRM);
4611: fnd_msg_pub.ADD;

Line 4611: fnd_msg_pub.ADD;

4607: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);
4608: WHEN OTHERS THEN
4609: fnd_message.set_name('JTF', 'JTF_TASK_UNKNOWN_ERROR');
4610: fnd_message.set_token('P_TEXT', SQLCODE || SQLERRM);
4611: fnd_msg_pub.ADD;
4612: ROLLBACK TO delete_task_pub2;
4613: x_return_status := fnd_api.g_ret_sts_unexp_error;
4614: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);
4615: END;

Line 4614: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);

4610: fnd_message.set_token('P_TEXT', SQLCODE || SQLERRM);
4611: fnd_msg_pub.ADD;
4612: ROLLBACK TO delete_task_pub2;
4613: x_return_status := fnd_api.g_ret_sts_unexp_error;
4614: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);
4615: END;
4616:
4617: -- New Version
4618: PROCEDURE delete_task(

Line 4645: fnd_msg_pub.initialize;

4641: RAISE fnd_api.g_exc_unexpected_error;
4642: END IF;
4643:
4644: IF fnd_api.to_boolean(p_init_msg_list) THEN
4645: fnd_msg_pub.initialize;
4646: END IF;
4647:
4648: IF (l_task_id IS NULL AND l_task_number IS NULL) THEN
4649: fnd_message.set_name('JTF', 'JTF_TASK_MISSING_TASK');

Line 4650: fnd_msg_pub.ADD;

4646: END IF;
4647:
4648: IF (l_task_id IS NULL AND l_task_number IS NULL) THEN
4649: fnd_message.set_name('JTF', 'JTF_TASK_MISSING_TASK');
4650: fnd_msg_pub.ADD;
4651: x_return_status := fnd_api.g_ret_sts_unexp_error;
4652: RAISE fnd_api.g_exc_unexpected_error;
4653: ELSE
4654: jtf_task_utl.validate_task(

Line 4690: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);

4686: IF fnd_api.to_boolean(p_commit) THEN
4687: COMMIT WORK;
4688: END IF;
4689:
4690: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);
4691: EXCEPTION
4692: WHEN fnd_api.g_exc_unexpected_error THEN
4693: ROLLBACK TO delete_task_pub;
4694: x_return_status := fnd_api.g_ret_sts_unexp_error;

Line 4695: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);

4691: EXCEPTION
4692: WHEN fnd_api.g_exc_unexpected_error THEN
4693: ROLLBACK TO delete_task_pub;
4694: x_return_status := fnd_api.g_ret_sts_unexp_error;
4695: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);
4696: WHEN OTHERS THEN
4697: fnd_message.set_name('JTF', 'JTF_TASK_UNKNOWN_ERROR');
4698: fnd_message.set_token('P_TEXT', SQLCODE || SQLERRM);
4699: fnd_msg_pub.ADD;

Line 4699: fnd_msg_pub.ADD;

4695: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);
4696: WHEN OTHERS THEN
4697: fnd_message.set_name('JTF', 'JTF_TASK_UNKNOWN_ERROR');
4698: fnd_message.set_token('P_TEXT', SQLCODE || SQLERRM);
4699: fnd_msg_pub.ADD;
4700: ROLLBACK TO delete_task_pub;
4701: x_return_status := fnd_api.g_ret_sts_unexp_error;
4702: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);
4703: END;

Line 4702: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);

4698: fnd_message.set_token('P_TEXT', SQLCODE || SQLERRM);
4699: fnd_msg_pub.ADD;
4700: ROLLBACK TO delete_task_pub;
4701: x_return_status := fnd_api.g_ret_sts_unexp_error;
4702: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);
4703: END;
4704:
4705: PROCEDURE export_query_task -- INPUT VARIABLES
4706:

Line 4837: fnd_msg_pub.initialize;

4833: END IF;
4834:
4835: -- initialize message list i p_init_msg_list is set to true
4836: IF (fnd_api.to_boolean(p_init_msg_list)) THEN
4837: fnd_msg_pub.initialize;
4838: END IF;
4839:
4840: export_query_task(
4841: p_api_version => p_api_version

Line 4907: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);

4903: );
4904: EXCEPTION
4905: WHEN fnd_api.g_exc_error THEN
4906: x_return_status := fnd_api.g_ret_sts_error;
4907: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);
4908: WHEN fnd_api.g_exc_unexpected_error THEN
4909: x_return_status := fnd_api.g_ret_sts_unexp_error;
4910: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);
4911: WHEN OTHERS THEN

Line 4910: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);

4906: x_return_status := fnd_api.g_ret_sts_error;
4907: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);
4908: WHEN fnd_api.g_exc_unexpected_error THEN
4909: x_return_status := fnd_api.g_ret_sts_unexp_error;
4910: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);
4911: WHEN OTHERS THEN
4912: x_return_status := fnd_api.g_ret_sts_unexp_error;
4913:
4914: IF fnd_msg_pub.check_msg_level(fnd_msg_pub.g_msg_lvl_unexp_error) THEN

Line 4914: IF fnd_msg_pub.check_msg_level(fnd_msg_pub.g_msg_lvl_unexp_error) THEN

4910: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);
4911: WHEN OTHERS THEN
4912: x_return_status := fnd_api.g_ret_sts_unexp_error;
4913:
4914: IF fnd_msg_pub.check_msg_level(fnd_msg_pub.g_msg_lvl_unexp_error) THEN
4915: fnd_msg_pub.add_exc_msg(g_pkg_name, l_api_name);
4916: END IF;
4917:
4918: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);

Line 4915: fnd_msg_pub.add_exc_msg(g_pkg_name, l_api_name);

4911: WHEN OTHERS THEN
4912: x_return_status := fnd_api.g_ret_sts_unexp_error;
4913:
4914: IF fnd_msg_pub.check_msg_level(fnd_msg_pub.g_msg_lvl_unexp_error) THEN
4915: fnd_msg_pub.add_exc_msg(g_pkg_name, l_api_name);
4916: END IF;
4917:
4918: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);
4919: END export_query_task;

Line 4918: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);

4914: IF fnd_msg_pub.check_msg_level(fnd_msg_pub.g_msg_lvl_unexp_error) THEN
4915: fnd_msg_pub.add_exc_msg(g_pkg_name, l_api_name);
4916: END IF;
4917:
4918: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);
4919: END export_query_task;
4920:
4921: PROCEDURE export_query_task -- INPUT VARIABLES
4922:

Line 5055: fnd_msg_pub.initialize;

5051: END IF;
5052:
5053: -- initialize message list i p_init_msg_list is set to true
5054: IF (fnd_api.to_boolean(p_init_msg_list)) THEN
5055: fnd_msg_pub.initialize;
5056: END IF;
5057:
5058: query_task(
5059: p_api_version

Line 5135: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);

5131: );
5132: EXCEPTION
5133: WHEN fnd_api.g_exc_error THEN
5134: x_return_status := fnd_api.g_ret_sts_error;
5135: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);
5136: WHEN fnd_api.g_exc_unexpected_error THEN
5137: x_return_status := fnd_api.g_ret_sts_unexp_error;
5138: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);
5139: WHEN OTHERS THEN

Line 5138: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);

5134: x_return_status := fnd_api.g_ret_sts_error;
5135: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);
5136: WHEN fnd_api.g_exc_unexpected_error THEN
5137: x_return_status := fnd_api.g_ret_sts_unexp_error;
5138: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);
5139: WHEN OTHERS THEN
5140: x_return_status := fnd_api.g_ret_sts_unexp_error;
5141:
5142: IF fnd_msg_pub.check_msg_level(fnd_msg_pub.g_msg_lvl_unexp_error) THEN

Line 5142: IF fnd_msg_pub.check_msg_level(fnd_msg_pub.g_msg_lvl_unexp_error) THEN

5138: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);
5139: WHEN OTHERS THEN
5140: x_return_status := fnd_api.g_ret_sts_unexp_error;
5141:
5142: IF fnd_msg_pub.check_msg_level(fnd_msg_pub.g_msg_lvl_unexp_error) THEN
5143: fnd_msg_pub.add_exc_msg(g_pkg_name, l_api_name);
5144: END IF;
5145:
5146: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);

Line 5143: fnd_msg_pub.add_exc_msg(g_pkg_name, l_api_name);

5139: WHEN OTHERS THEN
5140: x_return_status := fnd_api.g_ret_sts_unexp_error;
5141:
5142: IF fnd_msg_pub.check_msg_level(fnd_msg_pub.g_msg_lvl_unexp_error) THEN
5143: fnd_msg_pub.add_exc_msg(g_pkg_name, l_api_name);
5144: END IF;
5145:
5146: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);
5147: END export_query_task;

Line 5146: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);

5142: IF fnd_msg_pub.check_msg_level(fnd_msg_pub.g_msg_lvl_unexp_error) THEN
5143: fnd_msg_pub.add_exc_msg(g_pkg_name, l_api_name);
5144: END IF;
5145:
5146: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);
5147: END export_query_task;
5148:
5149: PROCEDURE export_file(
5150: p_api_version IN NUMBER

Line 5177: fnd_msg_pub.initialize;

5173: END IF;
5174:
5175: -- initialize message list i p_init_msg_list is set to true
5176: IF (fnd_api.to_boolean(p_init_msg_list)) THEN
5177: fnd_msg_pub.initialize;
5178: END IF;
5179:
5180: -- required parameters to control records returned
5181:

Line 5200: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);

5196: EXCEPTION
5197: WHEN fnd_api.g_exc_error THEN
5198: ROLLBACK TO query_next_task;
5199: x_return_status := fnd_api.g_ret_sts_error;
5200: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);
5201: WHEN fnd_api.g_exc_unexpected_error THEN
5202: ROLLBACK TO query_next_task;
5203: x_return_status := fnd_api.g_ret_sts_unexp_error;
5204: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);

Line 5204: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);

5200: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);
5201: WHEN fnd_api.g_exc_unexpected_error THEN
5202: ROLLBACK TO query_next_task;
5203: x_return_status := fnd_api.g_ret_sts_unexp_error;
5204: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);
5205: WHEN OTHERS THEN
5206: ROLLBACK TO query_next_task;
5207: x_return_status := fnd_api.g_ret_sts_unexp_error;
5208:

Line 5209: IF fnd_msg_pub.check_msg_level(fnd_msg_pub.g_msg_lvl_unexp_error) THEN

5205: WHEN OTHERS THEN
5206: ROLLBACK TO query_next_task;
5207: x_return_status := fnd_api.g_ret_sts_unexp_error;
5208:
5209: IF fnd_msg_pub.check_msg_level(fnd_msg_pub.g_msg_lvl_unexp_error) THEN
5210: fnd_msg_pub.add_exc_msg(g_pkg_name, l_api_name);
5211: END IF;
5212:
5213: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);

Line 5210: fnd_msg_pub.add_exc_msg(g_pkg_name, l_api_name);

5206: ROLLBACK TO query_next_task;
5207: x_return_status := fnd_api.g_ret_sts_unexp_error;
5208:
5209: IF fnd_msg_pub.check_msg_level(fnd_msg_pub.g_msg_lvl_unexp_error) THEN
5210: fnd_msg_pub.add_exc_msg(g_pkg_name, l_api_name);
5211: END IF;
5212:
5213: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);
5214: END export_file;

Line 5213: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);

5209: IF fnd_msg_pub.check_msg_level(fnd_msg_pub.g_msg_lvl_unexp_error) THEN
5210: fnd_msg_pub.add_exc_msg(g_pkg_name, l_api_name);
5211: END IF;
5212:
5213: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);
5214: END export_file;
5215:
5216: PROCEDURE val_task(
5217: v_task_id IN OUT NOCOPY jtf_tasks_v.task_id%TYPE

Line 5245: fnd_msg_pub.ADD;

5241: CLOSE c_task_number;
5242:
5243: fnd_message.set_name('JTF', 'JTF_TASK_INVALID_TASK_NUMBER');
5244: fnd_message.set_token('P_TASK_NUMBER', p_task_number);
5245: fnd_msg_pub.ADD;
5246: RAISE fnd_api.g_exc_error;
5247: ELSE
5248: CLOSE c_task_number;
5249: END IF;

Line 5260: fnd_msg_pub.ADD;

5256: IF c_task_name%NOTFOUND THEN
5257: CLOSE c_task_name;
5258:
5259: fnd_message.set_name('JTF', 'JTF_TASK_INV_TK_NAME');
5260: fnd_msg_pub.ADD;
5261: RAISE fnd_api.g_exc_error;
5262: ELSE
5263: CLOSE c_task_name;
5264: END IF;

Line 5287: fnd_msg_pub.ADD;

5283: CLOSE c_task_id;
5284:
5285: fnd_message.set_name('JTF', 'JTF_TASK_INVALID_TASK_ID');
5286: fnd_message.set_token('P_TASK_ID', p_task_id);
5287: fnd_msg_pub.ADD;
5288: RAISE fnd_api.g_exc_error;
5289: ELSE
5290: CLOSE c_task_id;
5291: END IF;

Line 5301: fnd_msg_pub.ADD;

5297: IF (p_start IS NOT NULL) AND(p_end IS NOT NULL) THEN
5298: IF (p_end < p_start) THEN
5299: fnd_message.set_name('JTF', 'JTF_TASK_INVALID_DATES');
5300: fnd_message.set_token('P_DATE_TAG', p_start);
5301: fnd_msg_pub.ADD;
5302: RAISE fnd_api.g_exc_error;
5303: END IF;
5304: END IF;
5305: END val_dates;

Line 5328: fnd_msg_pub.ADD;

5324: IF c_assigned_by_name%NOTFOUND THEN
5325: CLOSE c_assigned_by_name;
5326:
5327: fnd_message.set_name('JTF', 'JTF_TASK_INVALID_ASSIGNED_NAME');
5328: fnd_msg_pub.ADD;
5329: RAISE fnd_api.g_exc_error;
5330: ELSE
5331: CLOSE c_assigned_by_name;
5332: END IF;

Line 5358: fnd_msg_pub.ADD;

5354: CLOSE c_object_type_name;
5355:
5356: fnd_message.set_name('JTF', 'JTF_TASK_INVALID_OBJECT_CODE');
5357: fnd_message.set_token('P_object_type_code', p_object_name);
5358: fnd_msg_pub.ADD;
5359: RAISE fnd_api.g_exc_error;
5360: ELSE
5361: CLOSE c_object_type_name;
5362: END IF;

Line 5392: fnd_msg_pub.ADD;

5388: CLOSE c2;
5389:
5390: fnd_message.set_name('JTF', 'JTF_TASK_INVALID_CUST_NUMBER');
5391: fnd_message.set_token('P_customer_number', p_customer_number);
5392: fnd_msg_pub.ADD;
5393: RAISE fnd_api.g_exc_error;
5394: ELSE
5395: CLOSE c2;
5396: END IF;

Line 5408: fnd_msg_pub.ADD;

5404: CLOSE c1;
5405:
5406: fnd_message.set_name('JTF', 'JTF_TASK_INVALID_CUST_NAME');
5407: fnd_message.set_token('P_customer_name', p_customer_name);
5408: fnd_msg_pub.ADD;
5409: RAISE fnd_api.g_exc_error;
5410: ELSE
5411: CLOSE c1;
5412: END IF;

Line 5436: fnd_msg_pub.ADD;

5432: CLOSE c1;
5433:
5434: fnd_message.set_name('JTF', 'JTF_TASK_INVALID_CUST_ACCT_NUM');
5435: fnd_message.set_token('P_CUST_ACCOUNT_NUMBER', p_cust_account_number);
5436: fnd_msg_pub.ADD;
5437: RAISE fnd_api.g_exc_error;
5438: ELSE
5439: CLOSE c1;
5440: END IF;

Line 5466: fnd_msg_pub.ADD;

5462: CLOSE c_task_priority_name;
5463:
5464: fnd_message.set_name('JTF', 'JTF_TASK_INVALID_PRIORITY_NAME');
5465: fnd_message.set_token('P_TASK_PRIORITY_NAME', p_task_priority_name);
5466: fnd_msg_pub.ADD;
5467: RAISE fnd_api.g_exc_error;
5468: ELSE
5469: CLOSE c_task_priority_name;
5470: END IF;

Line 5600: fnd_msg_pub.initialize;

5596: END IF;
5597:
5598: -- initialize message list i p_init_msg_list is set to true
5599: IF (fnd_api.to_boolean(p_init_msg_list)) THEN
5600: fnd_msg_pub.initialize;
5601: END IF;
5602:
5603: query_task(
5604: p_api_version => p_api_version

Line 5670: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);

5666: EXCEPTION
5667: WHEN fnd_api.g_exc_error THEN
5668: ROLLBACK TO query_task_pub1;
5669: x_return_status := fnd_api.g_ret_sts_error;
5670: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);
5671: WHEN fnd_api.g_exc_unexpected_error THEN
5672: ROLLBACK TO query_task_pub1;
5673: x_return_status := fnd_api.g_ret_sts_unexp_error;
5674: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);

Line 5674: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);

5670: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);
5671: WHEN fnd_api.g_exc_unexpected_error THEN
5672: ROLLBACK TO query_task_pub1;
5673: x_return_status := fnd_api.g_ret_sts_unexp_error;
5674: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);
5675: WHEN OTHERS THEN
5676: ROLLBACK TO query_task_pub1;
5677: x_return_status := fnd_api.g_ret_sts_unexp_error;
5678:

Line 5679: IF fnd_msg_pub.check_msg_level(fnd_msg_pub.g_msg_lvl_unexp_error) THEN

5675: WHEN OTHERS THEN
5676: ROLLBACK TO query_task_pub1;
5677: x_return_status := fnd_api.g_ret_sts_unexp_error;
5678:
5679: IF fnd_msg_pub.check_msg_level(fnd_msg_pub.g_msg_lvl_unexp_error) THEN
5680: fnd_msg_pub.add_exc_msg(g_pkg_name, l_api_name);
5681: END IF;
5682:
5683: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);

Line 5680: fnd_msg_pub.add_exc_msg(g_pkg_name, l_api_name);

5676: ROLLBACK TO query_task_pub1;
5677: x_return_status := fnd_api.g_ret_sts_unexp_error;
5678:
5679: IF fnd_msg_pub.check_msg_level(fnd_msg_pub.g_msg_lvl_unexp_error) THEN
5680: fnd_msg_pub.add_exc_msg(g_pkg_name, l_api_name);
5681: END IF;
5682:
5683: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);
5684: END query_task;

Line 5683: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);

5679: IF fnd_msg_pub.check_msg_level(fnd_msg_pub.g_msg_lvl_unexp_error) THEN
5680: fnd_msg_pub.add_exc_msg(g_pkg_name, l_api_name);
5681: END IF;
5682:
5683: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);
5684: END query_task;
5685:
5686: PROCEDURE query_task -- possible query variables which are named after fields in jtf_tasks_v
5687:

Line 5822: fnd_msg_pub.initialize;

5818: END IF;
5819:
5820: -- initialize message list i p_init_msg_list is set to true
5821: IF (fnd_api.to_boolean(p_init_msg_list)) THEN
5822: fnd_msg_pub.initialize;
5823: END IF;
5824:
5825: -- required parameters to control records returned
5826:

Line 5831: fnd_msg_pub.ADD;

5827: -- p_ref_object_type_code or p_ref object_id is not null then both must exist
5828: IF (p_ref_object_type_code IS NOT NULL) OR(p_ref_object_id IS NOT NULL) THEN
5829: IF (p_ref_object_type_code IS NULL) OR(p_ref_object_id IS NULL) THEN
5830: fnd_message.set_name('JTF', 'JTF_TK_OBJECT_TYPE_ID_RQD');
5831: fnd_msg_pub.ADD;
5832: RAISE fnd_api.g_exc_error;
5833: END IF;
5834: END IF;
5835:

Line 5839: fnd_msg_pub.ADD;

5835:
5836: -- p_query_or_next_code should be Q or N
5837: IF (p_query_or_next_code NOT IN('Q', 'N')) OR(p_query_or_next_code IS NULL) THEN
5838: fnd_message.set_name('JTF', 'JTF_TK_INV_QRY_NXT');
5839: fnd_msg_pub.ADD;
5840: RAISE fnd_api.g_exc_error;
5841: END IF;
5842:
5843: -- p_show_all should be Y or N

Line 5846: fnd_msg_pub.ADD;

5842:
5843: -- p_show_all should be Y or N
5844: IF (p_show_all NOT IN('Y', 'N')) OR(p_show_all IS NULL) THEN
5845: fnd_message.set_name('JTF', 'JTF_TK_INV_SHOW_ALL');
5846: fnd_msg_pub.ADD;
5847: RAISE fnd_api.g_exc_error;
5848: END IF;
5849:
5850: IF (p_show_all = 'N') THEN

Line 5853: fnd_msg_pub.ADD;

5849:
5850: IF (p_show_all = 'N') THEN
5851: IF (p_start_pointer IS NULL) THEN
5852: fnd_message.set_name('JTF', 'JTF_TK_NULL_STRT_PTR');
5853: fnd_msg_pub.ADD;
5854: RAISE fnd_api.g_exc_error;
5855: END IF;
5856:
5857: IF (p_rec_wanted IS NULL) THEN

Line 5859: fnd_msg_pub.ADD;

5855: END IF;
5856:
5857: IF (p_rec_wanted IS NULL) THEN
5858: fnd_message.set_name('JTF', 'JTF_TK_NULL_REC_WANT');
5859: fnd_msg_pub.ADD;
5860: RAISE fnd_api.g_exc_error;
5861: END IF;
5862: END IF;
5863:

Line 6052: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);

6048: EXCEPTION
6049: WHEN fnd_api.g_exc_error THEN
6050: ROLLBACK TO query_task_pub2;
6051: x_return_status := fnd_api.g_ret_sts_error;
6052: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);
6053: WHEN fnd_api.g_exc_unexpected_error THEN
6054: ROLLBACK TO query_task_pub2;
6055: x_return_status := fnd_api.g_ret_sts_unexp_error;
6056: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);

Line 6056: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);

6052: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);
6053: WHEN fnd_api.g_exc_unexpected_error THEN
6054: ROLLBACK TO query_task_pub2;
6055: x_return_status := fnd_api.g_ret_sts_unexp_error;
6056: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);
6057: WHEN OTHERS THEN
6058: ROLLBACK TO query_task_pub2;
6059: x_return_status := fnd_api.g_ret_sts_unexp_error;
6060:

Line 6061: IF fnd_msg_pub.check_msg_level(fnd_msg_pub.g_msg_lvl_unexp_error) THEN

6057: WHEN OTHERS THEN
6058: ROLLBACK TO query_task_pub2;
6059: x_return_status := fnd_api.g_ret_sts_unexp_error;
6060:
6061: IF fnd_msg_pub.check_msg_level(fnd_msg_pub.g_msg_lvl_unexp_error) THEN
6062: fnd_msg_pub.add_exc_msg(g_pkg_name, l_api_name);
6063: END IF;
6064:
6065: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);

Line 6062: fnd_msg_pub.add_exc_msg(g_pkg_name, l_api_name);

6058: ROLLBACK TO query_task_pub2;
6059: x_return_status := fnd_api.g_ret_sts_unexp_error;
6060:
6061: IF fnd_msg_pub.check_msg_level(fnd_msg_pub.g_msg_lvl_unexp_error) THEN
6062: fnd_msg_pub.add_exc_msg(g_pkg_name, l_api_name);
6063: END IF;
6064:
6065: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);
6066: END query_task;

Line 6065: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);

6061: IF fnd_msg_pub.check_msg_level(fnd_msg_pub.g_msg_lvl_unexp_error) THEN
6062: fnd_msg_pub.add_exc_msg(g_pkg_name, l_api_name);
6063: END IF;
6064:
6065: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);
6066: END query_task;
6067:
6068: PROCEDURE query_next_task -- INPUT VARIABLES
6069:

Line 6138: fnd_msg_pub.initialize;

6134: END IF;
6135:
6136: -- initialize message list i p_init_msg_list is set to true
6137: IF (fnd_api.to_boolean(p_init_msg_list)) THEN
6138: fnd_msg_pub.initialize;
6139: END IF;
6140:
6141: -- required parameters to control records returned
6142:

Line 6146: fnd_msg_pub.ADD;

6142:
6143: -- p_query_or_next_code should be Q or N
6144: IF (p_query_or_next_code NOT IN('Q', 'N')) OR(p_query_or_next_code IS NULL) THEN
6145: fnd_message.set_name('JTF', 'JTF_TK_INV_QRY_NXT');
6146: fnd_msg_pub.ADD;
6147: RAISE fnd_api.g_exc_error;
6148: END IF;
6149:
6150: -- p_show_all should be Y or N

Line 6153: fnd_msg_pub.ADD;

6149:
6150: -- p_show_all should be Y or N
6151: IF (p_show_all NOT IN('Y', 'N')) OR(p_show_all IS NULL) THEN
6152: fnd_message.set_name('JTF', 'JTF_TK_INV_SHOW_ALL');
6153: fnd_msg_pub.ADD;
6154: RAISE fnd_api.g_exc_error;
6155: END IF;
6156:
6157: IF (p_show_all = 'N') THEN

Line 6160: fnd_msg_pub.ADD;

6156:
6157: IF (p_show_all = 'N') THEN
6158: IF (p_start_pointer IS NULL) THEN
6159: fnd_message.set_name('JTF', 'JTF_TK_NULL_STRT_PTR');
6160: fnd_msg_pub.ADD;
6161: RAISE fnd_api.g_exc_error;
6162: END IF;
6163:
6164: IF (p_rec_wanted IS NULL) THEN

Line 6166: fnd_msg_pub.ADD;

6162: END IF;
6163:
6164: IF (p_rec_wanted IS NULL) THEN
6165: fnd_message.set_name('JTF', 'JTF_TK_NULL_REC_WANT');
6166: fnd_msg_pub.ADD;
6167: RAISE fnd_api.g_exc_error;
6168: END IF;
6169: END IF;
6170:

Line 6174: fnd_msg_pub.ADD;

6170:
6171: -- parameters to control querying
6172: IF (l_query_type NOT IN('DEPENDENCY', 'ASSIGNED', 'OWNER')) THEN
6173: fnd_message.set_name('JTF', 'JTF_TK_QRY_NXT_INV_QRY_TYP');
6174: fnd_msg_pub.ADD;
6175: RAISE fnd_api.g_exc_error;
6176: ELSE
6177: -- check date_type and date_start_or_end
6178: IF (l_date_type NOT IN('SCHEDULED', 'PLANNED', 'ACTUAL')) THEN

Line 6180: fnd_msg_pub.ADD;

6176: ELSE
6177: -- check date_type and date_start_or_end
6178: IF (l_date_type NOT IN('SCHEDULED', 'PLANNED', 'ACTUAL')) THEN
6179: fnd_message.set_name('JTF', 'JTF_TK_QRY_NXT_INV_DT_TYPE');
6180: fnd_msg_pub.ADD;
6181: RAISE fnd_api.g_exc_error;
6182: END IF;
6183:
6184: IF (l_date_start_or_end NOT IN('END', 'START')) THEN

Line 6186: fnd_msg_pub.ADD;

6182: END IF;
6183:
6184: IF (l_date_start_or_end NOT IN('END', 'START')) THEN
6185: fnd_message.set_name('JTF', 'JTF_TK_QRY_NXT_INV_STRT_END_DT');
6186: fnd_msg_pub.ADD;
6187: RAISE fnd_api.g_exc_error;
6188: END IF;
6189:
6190: IF (l_query_type = 'ASSIGNED') THEN

Line 6193: fnd_msg_pub.ADD;

6189:
6190: IF (l_query_type = 'ASSIGNED') THEN
6191: IF (p_assigned_by IS NULL) THEN
6192: fnd_message.set_name('JTF', 'JTF_TK_QRY_NXT_NUL_ASGND_BY');
6193: fnd_msg_pub.ADD;
6194: RAISE fnd_api.g_exc_error;
6195: END IF;
6196: ELSIF(l_query_type = 'OWNER') THEN
6197: IF (p_owner_type_code IS NULL OR p_owner_id IS NULL) THEN

Line 6199: fnd_msg_pub.ADD;

6195: END IF;
6196: ELSIF(l_query_type = 'OWNER') THEN
6197: IF (p_owner_type_code IS NULL OR p_owner_id IS NULL) THEN
6198: fnd_message.set_name('JTF', 'JTF_TK_QRY_NXT_NUL_OWNER');
6199: fnd_msg_pub.ADD;
6200: RAISE fnd_api.g_exc_error;
6201: END IF;
6202: END IF;
6203: END IF;

Line 6210: fnd_msg_pub.ADD;

6206:
6207: -- task id should not be null
6208: IF (p_task_id IS NULL) THEN
6209: fnd_message.set_name('JTF', 'JTF_TASK_MISSING_TASK');
6210: fnd_msg_pub.ADD;
6211: RAISE fnd_api.g_exc_error;
6212: END IF;
6213:
6214: -- check for valid task_id

Line 6242: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);

6238: EXCEPTION
6239: WHEN fnd_api.g_exc_error THEN
6240: ROLLBACK TO query_next_task;
6241: x_return_status := fnd_api.g_ret_sts_error;
6242: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);
6243: WHEN fnd_api.g_exc_unexpected_error THEN
6244: ROLLBACK TO query_next_task;
6245: x_return_status := fnd_api.g_ret_sts_unexp_error;
6246: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);

Line 6246: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);

6242: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);
6243: WHEN fnd_api.g_exc_unexpected_error THEN
6244: ROLLBACK TO query_next_task;
6245: x_return_status := fnd_api.g_ret_sts_unexp_error;
6246: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);
6247: WHEN OTHERS THEN
6248: ROLLBACK TO query_next_task;
6249: x_return_status := fnd_api.g_ret_sts_unexp_error;
6250:

Line 6251: IF fnd_msg_pub.check_msg_level(fnd_msg_pub.g_msg_lvl_unexp_error) THEN

6247: WHEN OTHERS THEN
6248: ROLLBACK TO query_next_task;
6249: x_return_status := fnd_api.g_ret_sts_unexp_error;
6250:
6251: IF fnd_msg_pub.check_msg_level(fnd_msg_pub.g_msg_lvl_unexp_error) THEN
6252: fnd_msg_pub.add_exc_msg(g_pkg_name, l_api_name);
6253: END IF;
6254:
6255: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);

Line 6252: fnd_msg_pub.add_exc_msg(g_pkg_name, l_api_name);

6248: ROLLBACK TO query_next_task;
6249: x_return_status := fnd_api.g_ret_sts_unexp_error;
6250:
6251: IF fnd_msg_pub.check_msg_level(fnd_msg_pub.g_msg_lvl_unexp_error) THEN
6252: fnd_msg_pub.add_exc_msg(g_pkg_name, l_api_name);
6253: END IF;
6254:
6255: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);
6256: END query_next_task;

Line 6255: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);

6251: IF fnd_msg_pub.check_msg_level(fnd_msg_pub.g_msg_lvl_unexp_error) THEN
6252: fnd_msg_pub.add_exc_msg(g_pkg_name, l_api_name);
6253: END IF;
6254:
6255: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);
6256: END query_next_task;
6257:
6258: -----------
6259: ----------- Copy Task

Line 6584: fnd_msg_pub.initialize;

6580: RAISE fnd_api.g_exc_unexpected_error;
6581: END IF;
6582:
6583: IF fnd_api.to_boolean(p_init_msg_list) THEN
6584: fnd_msg_pub.initialize;
6585: END IF;
6586:
6587: IF l_source_task_id IS NULL THEN
6588: x_return_status := fnd_api.g_ret_sts_unexp_error;

Line 6590: fnd_msg_pub.ADD;

6586:
6587: IF l_source_task_id IS NULL THEN
6588: x_return_status := fnd_api.g_ret_sts_unexp_error;
6589: fnd_message.set_name('JTF', 'JTF_TASK_MISSING_TASK_ID');
6590: fnd_msg_pub.ADD;
6591: RAISE fnd_api.g_exc_unexpected_error;
6592: END IF;
6593:
6594: jtf_task_utl.validate_task(

Line 6612: fnd_msg_pub.ADD;

6608: IF c_task%NOTFOUND THEN
6609: x_return_status := fnd_api.g_ret_sts_unexp_error;
6610: fnd_message.set_name('JTF', 'JTF_TASK_INVALID_TASK_ID');
6611: fnd_message.set_token('P_TASK_ID', l_source_task_id);
6612: fnd_msg_pub.ADD;
6613: RAISE fnd_api.g_exc_unexpected_error;
6614: CLOSE c_task;
6615: END IF;
6616:

Line 7157: fnd_msg_pub.ADD;

7153: WHEN NO_DATA_FOUND THEN
7154: x_return_status := fnd_api.g_ret_sts_unexp_error;
7155: fnd_message.set_name('JTF', 'JTF_TASK_INVALID_TASK_ID');
7156: fnd_message.set_token('P_TASK_ID', l_source_task_id);
7157: fnd_msg_pub.ADD;
7158: RAISE fnd_api.g_exc_unexpected_error;
7159: WHEN OTHERS THEN
7160: fnd_message.set_name('JTF', 'JTF_TASK_UNKNOWN_ERROR');
7161: fnd_message.set_token('P_TEXT', SQLCODE || SQLERRM);

Line 7163: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);

7159: WHEN OTHERS THEN
7160: fnd_message.set_name('JTF', 'JTF_TASK_UNKNOWN_ERROR');
7161: fnd_message.set_token('P_TEXT', SQLCODE || SQLERRM);
7162: x_return_status := fnd_api.g_ret_sts_unexp_error;
7163: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);
7164: RAISE fnd_api.g_exc_unexpected_error;
7165: END;
7166:
7167: IF l_recurrence_rule_id IS NOT NULL THEN

Line 7303: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);

7299: IF fnd_api.to_boolean(p_commit) THEN
7300: COMMIT WORK;
7301: END IF;
7302:
7303: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);
7304: EXCEPTION
7305: WHEN fnd_api.g_exc_unexpected_error THEN
7306: ROLLBACK TO copy_task;
7307: x_return_status := fnd_api.g_ret_sts_unexp_error;

Line 7308: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);

7304: EXCEPTION
7305: WHEN fnd_api.g_exc_unexpected_error THEN
7306: ROLLBACK TO copy_task;
7307: x_return_status := fnd_api.g_ret_sts_unexp_error;
7308: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);
7309:
7310: IF c_task%ISOPEN THEN
7311: CLOSE c_task;
7312: END IF;

Line 7354: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);

7350: ROLLBACK TO copy_task;
7351: fnd_message.set_name('JTF', 'JTF_TASK_UNKNOWN_ERROR');
7352: fnd_message.set_token('P_TEXT', SQLCODE || SQLERRM);
7353: x_return_status := fnd_api.g_ret_sts_unexp_error;
7354: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);
7355:
7356: IF c_task%ISOPEN THEN
7357: CLOSE c_task;
7358: END IF;

Line 7469: fnd_msg_pub.initialize;

7465: RAISE fnd_api.g_exc_unexpected_error;
7466: END IF;
7467:
7468: IF fnd_api.to_boolean(p_init_msg_list) THEN
7469: fnd_msg_pub.initialize;
7470: END IF;
7471:
7472: -- call new version, passing defaults for new functionality
7473: create_task_from_template(

Line 7544: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);

7540: IF fnd_api.to_boolean(p_commit) THEN
7541: COMMIT WORK;
7542: END IF;
7543:
7544: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);
7545: EXCEPTION
7546: WHEN fnd_api.g_exc_unexpected_error THEN
7547: ROLLBACK TO create_task_from_template_pub1;
7548: x_return_status := fnd_api.g_ret_sts_unexp_error;

Line 7549: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);

7545: EXCEPTION
7546: WHEN fnd_api.g_exc_unexpected_error THEN
7547: ROLLBACK TO create_task_from_template_pub1;
7548: x_return_status := fnd_api.g_ret_sts_unexp_error;
7549: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);
7550: WHEN OTHERS THEN
7551: ROLLBACK TO create_task_from_template_pub1;
7552: fnd_message.set_name('JTF', 'JTF_TASK_UNKNOWN_ERROR');
7553: fnd_message.set_token('P_TEXT', SQLCODE || SQLERRM);

Line 7554: fnd_msg_pub.ADD;

7550: WHEN OTHERS THEN
7551: ROLLBACK TO create_task_from_template_pub1;
7552: fnd_message.set_name('JTF', 'JTF_TASK_UNKNOWN_ERROR');
7553: fnd_message.set_token('P_TEXT', SQLCODE || SQLERRM);
7554: fnd_msg_pub.ADD;
7555: x_return_status := fnd_api.g_ret_sts_unexp_error;
7556: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);
7557: END;
7558:

Line 7556: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);

7552: fnd_message.set_name('JTF', 'JTF_TASK_UNKNOWN_ERROR');
7553: fnd_message.set_token('P_TEXT', SQLCODE || SQLERRM);
7554: fnd_msg_pub.ADD;
7555: x_return_status := fnd_api.g_ret_sts_unexp_error;
7556: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);
7557: END;
7558:
7559: -- New Version...
7560: PROCEDURE create_task_from_template(

Line 7636: fnd_msg_pub.initialize;

7632: RAISE fnd_api.g_exc_unexpected_error;
7633: END IF;
7634:
7635: IF fnd_api.to_boolean(p_init_msg_list) THEN
7636: fnd_msg_pub.initialize;
7637: END IF;
7638:
7639: l_task_template_group_info.task_template_group_id := p_task_template_group_id;
7640: l_task_template_group_info.owner_type_code := p_owner_type_code;

Line 7714: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);

7710: IF fnd_api.to_boolean(p_commit) THEN
7711: COMMIT WORK;
7712: END IF;
7713:
7714: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);
7715: EXCEPTION
7716: WHEN fnd_api.g_exc_unexpected_error THEN
7717: ROLLBACK TO create_task_from_template_pub; -- Fix Bug 2896377
7718: x_return_status := fnd_api.g_ret_sts_unexp_error;

Line 7719: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);

7715: EXCEPTION
7716: WHEN fnd_api.g_exc_unexpected_error THEN
7717: ROLLBACK TO create_task_from_template_pub; -- Fix Bug 2896377
7718: x_return_status := fnd_api.g_ret_sts_unexp_error;
7719: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);
7720: WHEN OTHERS THEN
7721: ROLLBACK TO create_task_from_template_pub; -- Fix Bug 2896377
7722: fnd_message.set_name('JTF', 'JTF_TASK_UNKNOWN_ERROR');
7723: fnd_message.set_token('P_TEXT', SQLCODE || SQLERRM);

Line 7724: fnd_msg_pub.ADD;

7720: WHEN OTHERS THEN
7721: ROLLBACK TO create_task_from_template_pub; -- Fix Bug 2896377
7722: fnd_message.set_name('JTF', 'JTF_TASK_UNKNOWN_ERROR');
7723: fnd_message.set_token('P_TEXT', SQLCODE || SQLERRM);
7724: fnd_msg_pub.ADD;
7725: x_return_status := fnd_api.g_ret_sts_unexp_error;
7726: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);
7727: END;
7728:

Line 7726: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);

7722: fnd_message.set_name('JTF', 'JTF_TASK_UNKNOWN_ERROR');
7723: fnd_message.set_token('P_TEXT', SQLCODE || SQLERRM);
7724: fnd_msg_pub.ADD;
7725: x_return_status := fnd_api.g_ret_sts_unexp_error;
7726: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);
7727: END;
7728:
7729: PROCEDURE lock_task(
7730: p_api_version IN NUMBER

Line 7752: fnd_msg_pub.initialize;

7748: RAISE fnd_api.g_exc_unexpected_error;
7749: END IF;
7750:
7751: IF fnd_api.to_boolean(p_init_msg_list) THEN
7752: fnd_msg_pub.initialize;
7753: END IF;
7754:
7755: x_return_status := fnd_api.g_ret_sts_success;
7756: jtf_tasks_pkg.lock_row(x_task_id => p_task_id

Line 7758: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);

7754:
7755: x_return_status := fnd_api.g_ret_sts_success;
7756: jtf_tasks_pkg.lock_row(x_task_id => p_task_id
7757: , x_object_version_number => p_object_version_number);
7758: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);
7759: EXCEPTION
7760: WHEN resource_locked THEN
7761: ROLLBACK TO lock_tasks_pub;
7762: fnd_message.set_name('JTF', 'JTF_TASK_RESOURCE_LOCKED');

Line 7765: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);

7761: ROLLBACK TO lock_tasks_pub;
7762: fnd_message.set_name('JTF', 'JTF_TASK_RESOURCE_LOCKED');
7763: fnd_message.set_token('P_LOCKED_RESOURCE', 'Task');
7764: x_return_status := fnd_api.g_ret_sts_unexp_error;
7765: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);
7766: WHEN fnd_api.g_exc_unexpected_error THEN
7767: ROLLBACK TO lock_tasks_pub;
7768: x_return_status := fnd_api.g_ret_sts_unexp_error;
7769: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);

Line 7769: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);

7765: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);
7766: WHEN fnd_api.g_exc_unexpected_error THEN
7767: ROLLBACK TO lock_tasks_pub;
7768: x_return_status := fnd_api.g_ret_sts_unexp_error;
7769: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);
7770: WHEN OTHERS THEN
7771: ROLLBACK TO lock_tasks_pub;
7772: fnd_message.set_name('JTF', 'JTF_TASK_UNKNOWN_ERROR');
7773: fnd_message.set_token('P_TEXT', SQLCODE || SQLERRM);

Line 7775: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);

7771: ROLLBACK TO lock_tasks_pub;
7772: fnd_message.set_name('JTF', 'JTF_TASK_UNKNOWN_ERROR');
7773: fnd_message.set_token('P_TEXT', SQLCODE || SQLERRM);
7774: x_return_status := fnd_api.g_ret_sts_unexp_error;
7775: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);
7776: END;
7777:
7778: ------
7779: ------ This procedure updates the Task record with the source object

Line 7809: fnd_msg_pub.initialize;

7805: RAISE fnd_api.g_exc_unexpected_error;
7806: END IF;
7807:
7808: IF fnd_api.to_boolean(p_init_msg_list) THEN
7809: fnd_msg_pub.initialize;
7810: END IF;
7811:
7812: -------
7813: ------- Check for truncation of source object name

Line 7872: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);

7868: IF fnd_api.to_boolean(p_commit) THEN
7869: COMMIT WORK;
7870: END IF;
7871:
7872: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);
7873: EXCEPTION
7874: WHEN fnd_api.g_exc_unexpected_error THEN
7875: ROLLBACK TO update_task_source;
7876: x_return_status := fnd_api.g_ret_sts_unexp_error;

Line 7877: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);

7873: EXCEPTION
7874: WHEN fnd_api.g_exc_unexpected_error THEN
7875: ROLLBACK TO update_task_source;
7876: x_return_status := fnd_api.g_ret_sts_unexp_error;
7877: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);
7878: WHEN OTHERS THEN
7879: ROLLBACK TO update_task_source;
7880: fnd_message.set_name('JTF', 'JTF_TASK_UNKNOWN_ERROR');
7881: fnd_message.set_token('P_TEXT', SQLCODE || SQLERRM);

Line 7883: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);

7879: ROLLBACK TO update_task_source;
7880: fnd_message.set_name('JTF', 'JTF_TASK_UNKNOWN_ERROR');
7881: fnd_message.set_token('P_TEXT', SQLCODE || SQLERRM);
7882: x_return_status := fnd_api.g_ret_sts_unexp_error;
7883: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);
7884: END;
7885:
7886: -- Function to check parameter length and throw error if length not in allowed limit bug # 3182170 Start
7887: FUNCTION check_param_length(

Line 7896: fnd_msg_pub.ADD;

7892: RETURN VARCHAR2 IS
7893: BEGIN
7894: IF LENGTH(p_task_name) > p_length THEN
7895: fnd_message.set_name('JTF', p_message_name);
7896: fnd_msg_pub.ADD;
7897: RAISE fnd_api.g_exc_unexpected_error;
7898: ELSE
7899: RETURN p_task_name;
7900: END IF;

Line 7959: fnd_msg_pub.initialize;

7955: RAISE fnd_api.g_exc_unexpected_error;
7956: END IF;
7957:
7958: IF fnd_api.to_boolean(p_init_msg_list) THEN
7959: fnd_msg_pub.initialize;
7960: END IF;
7961:
7962: OPEN c_task_validate(p_task_id);
7963:

Line 7970: fnd_msg_pub.ADD;

7966:
7967: IF c_task_validate%NOTFOUND THEN
7968: fnd_message.set_name('JTF', 'JTF_TASK_INVALID_TASK_ID');
7969: fnd_message.set_token('P_TASK_ID', p_task_id);
7970: fnd_msg_pub.ADD;
7971: RAISE fnd_api.g_exc_unexpected_error;
7972: END IF;
7973:
7974: CLOSE c_task_validate;

Line 7978: fnd_msg_pub.ADD;

7974: CLOSE c_task_validate;
7975:
7976: IF (p_task_split_flag IS NULL) THEN
7977: fnd_message.set_name('JTF', 'JTF_TASK_SPLIT_FLAG_NULL');
7978: fnd_msg_pub.ADD;
7979: RAISE fnd_api.g_exc_unexpected_error;
7980: END IF;
7981:
7982: IF (task_val.task_split_flag IS NULL) THEN

Line 7984: fnd_msg_pub.ADD;

7980: END IF;
7981:
7982: IF (task_val.task_split_flag IS NULL) THEN
7983: fnd_message.set_name('JTF', 'JTF_TASK_SPLIT_FLAG_NOT_EXIST');
7984: fnd_msg_pub.ADD;
7985: RAISE fnd_api.g_exc_unexpected_error;
7986: END IF;
7987:
7988: IF (task_val.task_split_flag <> 'D' OR task_val.task_split_flag <> 'M') THEN

Line 7992: fnd_msg_pub.ADD;

7988: IF (task_val.task_split_flag <> 'D' OR task_val.task_split_flag <> 'M') THEN
7989: fnd_message.set_name('JTF', 'JTF_TASK_SPLIT_FLAG_NOT_VALID');
7990: fnd_message.set_token('P_TASK_ID', p_task_id);
7991: fnd_message.set_token('P_TASK_SPLIT_FLAG', task_val.task_split_flag);
7992: fnd_msg_pub.ADD;
7993: RAISE fnd_api.g_exc_unexpected_error;
7994: END IF;
7995:
7996: IF (task_val.task_split_flag <> p_task_split_flag) THEN

Line 8000: fnd_msg_pub.ADD;

7996: IF (task_val.task_split_flag <> p_task_split_flag) THEN
7997: fnd_message.set_name('JTF', 'JTF_TASK_INVALID_SPLIT_FLAG');
7998: fnd_message.set_token('P_TASK_SPLIT_FLAG', p_task_split_flag);
7999: fnd_message.set_token('P_TASK_ID', p_task_id);
8000: fnd_msg_pub.ADD;
8001: RAISE fnd_api.g_exc_unexpected_error;
8002: END IF;
8003:
8004: IF (p_task_split_flag = 'D') THEN

Line 8101: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);

8097: IF fnd_api.to_boolean(p_commit) THEN
8098: COMMIT WORK;
8099: END IF;
8100:
8101: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);
8102: END IF;
8103: EXCEPTION
8104: WHEN fnd_api.g_exc_unexpected_error THEN
8105: ROLLBACK TO delete_split_tasks_pub;

Line 8107: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);

8103: EXCEPTION
8104: WHEN fnd_api.g_exc_unexpected_error THEN
8105: ROLLBACK TO delete_split_tasks_pub;
8106: x_return_status := fnd_api.g_ret_sts_unexp_error;
8107: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);
8108: WHEN OTHERS THEN
8109: fnd_message.set_name('JTF', 'JTF_TASK_UNKNOWN_ERROR');
8110: fnd_message.set_token('P_TEXT', SQLCODE || SQLERRM);
8111: fnd_msg_pub.ADD;

Line 8111: fnd_msg_pub.ADD;

8107: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);
8108: WHEN OTHERS THEN
8109: fnd_message.set_name('JTF', 'JTF_TASK_UNKNOWN_ERROR');
8110: fnd_message.set_token('P_TEXT', SQLCODE || SQLERRM);
8111: fnd_msg_pub.ADD;
8112: ROLLBACK TO delete_split_tasks_pub;
8113: x_return_status := fnd_api.g_ret_sts_unexp_error;
8114: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);
8115: END;

Line 8114: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);

8110: fnd_message.set_token('P_TEXT', SQLCODE || SQLERRM);
8111: fnd_msg_pub.ADD;
8112: ROLLBACK TO delete_split_tasks_pub;
8113: x_return_status := fnd_api.g_ret_sts_unexp_error;
8114: fnd_msg_pub.count_and_get(p_count => x_msg_count, p_data => x_msg_data);
8115: END;
8116:
8117: PROCEDURE MASS_TASK_UPDATE (
8118: P_API_VERSION IN NUMBER

Line 8395: fnd_msg_pub.get_Detail(p_msg_index => fnd_msg_pub.G_FIRST,

8391: rollback to mass_task_update;
8392: l_failed_reason_list.extend;
8393: l_failed_task_id_list.extend;
8394: l_failed_reason_list(l_failed_index):=
8395: fnd_msg_pub.get_Detail(p_msg_index => fnd_msg_pub.G_FIRST,
8396: p_encoded =>'F' );
8397: l_failed_task_id_list(l_failed_index):=P_TASK_ID_LIST(i);
8398: l_failed_index:=l_failed_index+1;
8399: END IF; -- end IF (l_update_status = 0)

Line 8404: l_failed_reason_list(l_failed_index):=fnd_msg_pub.get_Detail(p_msg_index => fnd_msg_pub.G_FIRST,

8400: ELSE
8401: rollback to mass_task_update;
8402: l_failed_reason_list.extend;
8403: l_failed_task_id_list.extend;
8404: l_failed_reason_list(l_failed_index):=fnd_msg_pub.get_Detail(p_msg_index => fnd_msg_pub.G_FIRST,
8405: p_encoded =>'F');
8406: l_failed_task_id_list(l_failed_index):=P_TASK_ID_LIST(i);
8407: l_failed_index:=l_failed_index+1;
8408: END IF; -- end IF (l_return_status = fnd_api.g_ret_sts_success)