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.CN_PROC_BATCHES_PKG dependencies on CN_MESSAGE_PKG

Line 25: 31-AUG-95 P Cook Pass process_audit_id to cn_message_pkg.end_batch

21: 14-AUG-95 P Cook Replace hardcoded trx batch size with system_batch_size
22: 18-AUG-95 P Cook Handle no_data_found in flood routine excep handlers
23: 30-AUG-95 P Cook Replaced 'raise app_exception' with 'raise' in
24: 'when others' to show the actual exception being raised
25: 31-AUG-95 P Cook Pass process_audit_id to cn_message_pkg.end_batch
26: so that it can fill in the completion timestamp.
27: Changed the 'no transactions to process' message from
28: debug to translated.
29: 26-OCT-95 P Cook Bug: 300974. Modified 'main' to give nice message if

Line 402: cn_message_pkg.DEBUG('Invalid process code: ' || x_physical_process);

398: ELSIF x_physical_process = g_post THEN
399: currst := g_post;
400: newst := g_post;
401: ELSE
402: cn_message_pkg.DEBUG('Invalid process code: ' || x_physical_process);
403: fnd_file.put_line(fnd_file.LOG, 'Invalid process code: ' || x_physical_process);
404: RAISE ABORT;
405: END IF;
406:

Line 428: cn_message_pkg.DEBUG(

424: x_physical_process := g_calculation; --g_logical_process;
425: ELSIF x_physical_process = g_calculation THEN
426: x_physical_process := NULL;
427: ELSE
428: cn_message_pkg.DEBUG(
429: 'Invalid process code: '
430: || x_physical_process
431: || ' (logical process: '
432: || g_logical_process

Line 463: cn_message_pkg.DEBUG(

459: newpr := g_classification;
460: ELSIF x_physical_process = g_classification THEN
461: newpr := NULL;
462: ELSE
463: cn_message_pkg.DEBUG(
464: 'Invalid process code: '
465: || x_physical_process
466: || ' (logical process: '
467: || g_logical_process

Line 488: cn_message_pkg.DEBUG(

484: newpr := g_rollup;
485: ELSIF x_physical_process = g_rollup THEN
486: newpr := NULL;
487: ELSE
488: cn_message_pkg.DEBUG(
489: 'Invalid process code: '
490: || x_physical_process
491: || ' (logical process: '
492: || g_logical_process

Line 515: cn_message_pkg.DEBUG(

511: newpr := g_population;
512: ELSIF x_physical_process = g_population THEN
513: newpr := NULL;
514: ELSE
515: cn_message_pkg.DEBUG(
516: 'Invalid process code: '
517: || x_physical_process
518: || ' (logical process: '
519: || g_logical_process

Line 546: cn_message_pkg.DEBUG(

542: newpr := g_calculation;
543: ELSIF x_physical_process = g_calculation THEN
544: newpr := NULL;
545: ELSE
546: cn_message_pkg.DEBUG(
547: 'Invalid process code: '
548: || x_physical_process
549: || ' (logical process: '
550: || g_logical_process

Line 626: cn_message_pkg.DEBUG('Exception occurs in getting the descendants:');

622: , p_org_id => g_org_id
623: );
624:
625: IF l_return_status <> fnd_api.g_ret_sts_success THEN
626: cn_message_pkg.DEBUG('Exception occurs in getting the descendants:');
627:
628: FOR l_counter IN 1 .. l_msg_count LOOP
629: cn_message_pkg.DEBUG(fnd_msg_pub.get(p_msg_index => l_counter
630: , p_encoded => fnd_api.g_false));

Line 629: cn_message_pkg.DEBUG(fnd_msg_pub.get(p_msg_index => l_counter

625: IF l_return_status <> fnd_api.g_ret_sts_success THEN
626: cn_message_pkg.DEBUG('Exception occurs in getting the descendants:');
627:
628: FOR l_counter IN 1 .. l_msg_count LOOP
629: cn_message_pkg.DEBUG(fnd_msg_pub.get(p_msg_index => l_counter
630: , p_encoded => fnd_api.g_false));
631: END LOOP;
632:
633: RAISE api_call_failed;

Line 702: cn_message_pkg.DEBUG

698: , SQLERRM
699: );
700: END IF;
701:
702: cn_message_pkg.DEBUG
703: ('Exception occurs in including the descendants in the calc process:');
704: cn_message_pkg.DEBUG(SQLERRM);
705: RAISE;
706: END;

Line 704: cn_message_pkg.DEBUG(SQLERRM);

700: END IF;
701:
702: cn_message_pkg.DEBUG
703: ('Exception occurs in including the descendants in the calc process:');
704: cn_message_pkg.DEBUG(SQLERRM);
705: RAISE;
706: END;
707: END LOOP;
708: END IF; -- checking l_descendant_tbl.count > 0

Line 779: cn_message_pkg.FLUSH;

775: , fnd_msg_pub.get(p_msg_index => l_counter, p_encoded => fnd_api.g_false));
776: END LOOP;
777: END IF;
778:
779: cn_message_pkg.FLUSH;
780: WHEN OTHERS THEN
781: fnd_file.put_line(fnd_file.LOG, 'In cn_proc_batches_pkg.populate_calcsub_batch: ' || SQLERRM);
782: cn_message_pkg.DEBUG('Exception occurs in cn_proc_batches_pkg.populate_calcsub_batch:');
783: cn_message_pkg.rollback_errormsg_commit(SQLERRM);

Line 782: cn_message_pkg.DEBUG('Exception occurs in cn_proc_batches_pkg.populate_calcsub_batch:');

778:
779: cn_message_pkg.FLUSH;
780: WHEN OTHERS THEN
781: fnd_file.put_line(fnd_file.LOG, 'In cn_proc_batches_pkg.populate_calcsub_batch: ' || SQLERRM);
782: cn_message_pkg.DEBUG('Exception occurs in cn_proc_batches_pkg.populate_calcsub_batch:');
783: cn_message_pkg.rollback_errormsg_commit(SQLERRM);
784:
785: IF (fnd_log.level_unexpected >= fnd_log.g_current_runtime_level) THEN
786: fnd_log.STRING(

Line 783: cn_message_pkg.rollback_errormsg_commit(SQLERRM);

779: cn_message_pkg.FLUSH;
780: WHEN OTHERS THEN
781: fnd_file.put_line(fnd_file.LOG, 'In cn_proc_batches_pkg.populate_calcsub_batch: ' || SQLERRM);
782: cn_message_pkg.DEBUG('Exception occurs in cn_proc_batches_pkg.populate_calcsub_batch:');
783: cn_message_pkg.rollback_errormsg_commit(SQLERRM);
784:
785: IF (fnd_log.level_unexpected >= fnd_log.g_current_runtime_level) THEN
786: fnd_log.STRING(
787: fnd_log.level_unexpected

Line 1556: cn_message_pkg.DEBUG('Exception occurs in cn_proc_batches_pkg.populate_process_batch:');

1552: (
1553: fnd_file.LOG
1554: , 'Exception occurs in cn_proc_batches_pkg.populate_process_batch: No one with complete compensation plan to calculate.'
1555: );
1556: cn_message_pkg.DEBUG('Exception occurs in cn_proc_batches_pkg.populate_process_batch:');
1557: cn_message_pkg.rollback_errormsg_commit
1558: ('No one with complete compensation plan to calculate.');
1559: RAISE;
1560: WHEN OTHERS THEN

Line 1557: cn_message_pkg.rollback_errormsg_commit

1553: fnd_file.LOG
1554: , 'Exception occurs in cn_proc_batches_pkg.populate_process_batch: No one with complete compensation plan to calculate.'
1555: );
1556: cn_message_pkg.DEBUG('Exception occurs in cn_proc_batches_pkg.populate_process_batch:');
1557: cn_message_pkg.rollback_errormsg_commit
1558: ('No one with complete compensation plan to calculate.');
1559: RAISE;
1560: WHEN OTHERS THEN
1561: fnd_file.put_line(fnd_file.LOG, 'In cn_proc_batches_pkg.populate_process_batch:' || SQLERRM);

Line 1571: cn_message_pkg.DEBUG('Exception occurs in cn_proc_batches_pkg.populate_process_batch: ');

1567: , SQLERRM
1568: );
1569: END IF;
1570:
1571: cn_message_pkg.DEBUG('Exception occurs in cn_proc_batches_pkg.populate_process_batch: ');
1572: cn_message_pkg.rollback_errormsg_commit(SQLERRM);
1573: RAISE;
1574: END populate_process_batch;
1575:

Line 1572: cn_message_pkg.rollback_errormsg_commit(SQLERRM);

1568: );
1569: END IF;
1570:
1571: cn_message_pkg.DEBUG('Exception occurs in cn_proc_batches_pkg.populate_process_batch: ');
1572: cn_message_pkg.rollback_errormsg_commit(SQLERRM);
1573: RAISE;
1574: END populate_process_batch;
1575:
1576: -- Procedure Name

Line 1619: cn_message_pkg.begin_batch(

1615: IF l_batch_rec.status = 'COMPLETE' THEN
1616: -- once completed, can not start it again
1617: NULL;
1618: ELSE
1619: cn_message_pkg.begin_batch(
1620: x_process_type => 'CALCULATION'
1621: , x_parent_proc_audit_id => NULL
1622: , x_process_audit_id => x_process_audit_id
1623: , x_request_id => fnd_global.conc_request_id

Line 1679: cn_message_pkg.set_name('CN', 'ALL_PROCESS_DONE_OK');

1675: , x_process_status_code => x_process_status_code
1676: );
1677: ELSE
1678: x_process_status_code := 'SUCCESS';
1679: cn_message_pkg.set_name('CN', 'ALL_PROCESS_DONE_OK');
1680: cn_message_pkg.end_batch(x_process_audit_id);
1681: END IF;
1682: END IF;
1683:

Line 1680: cn_message_pkg.end_batch(x_process_audit_id);

1676: );
1677: ELSE
1678: x_process_status_code := 'SUCCESS';
1679: cn_message_pkg.set_name('CN', 'ALL_PROCESS_DONE_OK');
1680: cn_message_pkg.end_batch(x_process_audit_id);
1681: END IF;
1682: END IF;
1683:
1684: IF (fnd_log.level_procedure >= fnd_log.g_current_runtime_level) THEN

Line 1698: cn_message_pkg.DEBUG('Exception occurs in cn_proc_batches_pkg.calculation_submission');

1694: (
1695: fnd_file.LOG
1696: , 'no_one_with_complete_plan EXCEPTION in cn_proc_batches_pkg.calculation_submission'
1697: );
1698: cn_message_pkg.DEBUG('Exception occurs in cn_proc_batches_pkg.calculation_submission');
1699: cn_message_pkg.rollback_errormsg_commit
1700: ('No resource with complete compensation plan to calculate.');
1701: cn_calc_sub_batches_pkg.update_calc_sub_batch(g_logical_batch_id, 'FAILED');
1702: COMMIT;

Line 1699: cn_message_pkg.rollback_errormsg_commit

1695: fnd_file.LOG
1696: , 'no_one_with_complete_plan EXCEPTION in cn_proc_batches_pkg.calculation_submission'
1697: );
1698: cn_message_pkg.DEBUG('Exception occurs in cn_proc_batches_pkg.calculation_submission');
1699: cn_message_pkg.rollback_errormsg_commit
1700: ('No resource with complete compensation plan to calculate.');
1701: cn_calc_sub_batches_pkg.update_calc_sub_batch(g_logical_batch_id, 'FAILED');
1702: COMMIT;
1703: app_exception.raise_exception;

Line 1708: cn_message_pkg.DEBUG('Exception occurs in cn_proc_batches_pkg.calculation_submission:');

1704: WHEN OTHERS THEN
1705: x_process_status_code := 'FAIL';
1706: fnd_file.put_line(fnd_file.LOG, 'Error in cn_proc_batches_pkg.calculation_submission.');
1707: fnd_file.put_line(fnd_file.LOG, SQLERRM);
1708: cn_message_pkg.DEBUG('Exception occurs in cn_proc_batches_pkg.calculation_submission:');
1709: cn_message_pkg.rollback_errormsg_commit(SQLERRM);
1710: cn_calc_sub_batches_pkg.update_calc_sub_batch(g_logical_batch_id, 'FAILED');
1711: COMMIT;
1712:

Line 1709: cn_message_pkg.rollback_errormsg_commit(SQLERRM);

1705: x_process_status_code := 'FAIL';
1706: fnd_file.put_line(fnd_file.LOG, 'Error in cn_proc_batches_pkg.calculation_submission.');
1707: fnd_file.put_line(fnd_file.LOG, SQLERRM);
1708: cn_message_pkg.DEBUG('Exception occurs in cn_proc_batches_pkg.calculation_submission:');
1709: cn_message_pkg.rollback_errormsg_commit(SQLERRM);
1710: cn_calc_sub_batches_pkg.update_calc_sub_batch(g_logical_batch_id, 'FAILED');
1711: COMMIT;
1712:
1713: IF (fnd_log.level_unexpected >= fnd_log.g_current_runtime_level) THEN

Line 1958: cn_message_pkg.set_name('CN', 'PROC_NO_TRX_TO_PROCESS');

1954: CLOSE reps;
1955: END IF;
1956:
1957: IF (reps_tbl.COUNT = 0) THEN
1958: cn_message_pkg.set_name('CN', 'PROC_NO_TRX_TO_PROCESS');
1959:
1960: IF (fnd_log.level_exception >= fnd_log.g_current_runtime_level) THEN
1961: fnd_log.STRING(
1962: fnd_log.level_exception

Line 2052: cn_message_pkg.DEBUG('Finish assigning resources to physical batches.');

2048: , 'Finish assigning resources to physical batches.'
2049: );
2050: END IF;
2051:
2052: cn_message_pkg.DEBUG('Finish assigning resources to physical batches.');
2053: cn_message_pkg.FLUSH;
2054: COMMIT;
2055: EXCEPTION
2056: WHEN no_comm_lines THEN

Line 2053: cn_message_pkg.FLUSH;

2049: );
2050: END IF;
2051:
2052: cn_message_pkg.DEBUG('Finish assigning resources to physical batches.');
2053: cn_message_pkg.FLUSH;
2054: COMMIT;
2055: EXCEPTION
2056: WHEN no_comm_lines THEN
2057: fnd_file.put_line(fnd_file.LOG, 'no_comm_lines exception in cn_proc_batches_pkg.assign');

Line 2058: cn_message_pkg.DEBUG('Exception occurs in cn_proc_batches_pkg.assign:');

2054: COMMIT;
2055: EXCEPTION
2056: WHEN no_comm_lines THEN
2057: fnd_file.put_line(fnd_file.LOG, 'no_comm_lines exception in cn_proc_batches_pkg.assign');
2058: cn_message_pkg.DEBUG('Exception occurs in cn_proc_batches_pkg.assign:');
2059: cn_message_pkg.DEBUG('No transactions to process.');
2060: RAISE;
2061: WHEN OTHERS THEN
2062: IF (fnd_log.level_unexpected >= fnd_log.g_current_runtime_level) THEN

Line 2059: cn_message_pkg.DEBUG('No transactions to process.');

2055: EXCEPTION
2056: WHEN no_comm_lines THEN
2057: fnd_file.put_line(fnd_file.LOG, 'no_comm_lines exception in cn_proc_batches_pkg.assign');
2058: cn_message_pkg.DEBUG('Exception occurs in cn_proc_batches_pkg.assign:');
2059: cn_message_pkg.DEBUG('No transactions to process.');
2060: RAISE;
2061: WHEN OTHERS THEN
2062: IF (fnd_log.level_unexpected >= fnd_log.g_current_runtime_level) THEN
2063: fnd_log.STRING(fnd_log.level_unexpected, 'cn.plsql.cn_proc_batches_pkg.assign.exception'

Line 2068: cn_message_pkg.DEBUG('Exception occurs in cn_proc_batches_pkg.assign:');

2064: , SQLERRM);
2065: END IF;
2066:
2067: fnd_file.put_line(fnd_file.LOG, 'In cn_proc_batches.assign: ' || SQLERRM);
2068: cn_message_pkg.DEBUG('Exception occurs in cn_proc_batches_pkg.assign:');
2069: cn_message_pkg.rollback_errormsg_commit(SQLERRM);
2070: RAISE;
2071: END assign;
2072:

Line 2069: cn_message_pkg.rollback_errormsg_commit(SQLERRM);

2065: END IF;
2066:
2067: fnd_file.put_line(fnd_file.LOG, 'In cn_proc_batches.assign: ' || SQLERRM);
2068: cn_message_pkg.DEBUG('Exception occurs in cn_proc_batches_pkg.assign:');
2069: cn_message_pkg.rollback_errormsg_commit(SQLERRM);
2070: RAISE;
2071: END assign;
2072:
2073: PROCEDURE update_error(x_physical_batch_id NUMBER) IS

Line 2128: cn_message_pkg.DEBUG('Failed to submit concurrent request (batch ID=' || x_physical_batch_id

2124: );
2125: END IF;
2126:
2127: fnd_file.put_line(fnd_file.LOG, 'Submission failure for batch' || x_physical_batch_id);
2128: cn_message_pkg.DEBUG('Failed to submit concurrent request (batch ID=' || x_physical_batch_id
2129: || ')');
2130: cn_message_pkg.DEBUG(fnd_message.get);
2131: -- raise conc_fail;
2132: ELSE

Line 2130: cn_message_pkg.DEBUG(fnd_message.get);

2126:
2127: fnd_file.put_line(fnd_file.LOG, 'Submission failure for batch' || x_physical_batch_id);
2128: cn_message_pkg.DEBUG('Failed to submit concurrent request (batch ID=' || x_physical_batch_id
2129: || ')');
2130: cn_message_pkg.DEBUG(fnd_message.get);
2131: -- raise conc_fail;
2132: ELSE
2133: cn_message_pkg.FLUSH;
2134: COMMIT;

Line 2133: cn_message_pkg.FLUSH;

2129: || ')');
2130: cn_message_pkg.DEBUG(fnd_message.get);
2131: -- raise conc_fail;
2132: ELSE
2133: cn_message_pkg.FLUSH;
2134: COMMIT;
2135: END IF;
2136: END conc_submit;
2137:

Line 2208: cn_message_pkg.FLUSH;

2204:
2205: -- Flood procedure calls
2206: -- flood_salesreps;
2207: flood_rev_classes;
2208: cn_message_pkg.FLUSH;
2209: COMMIT;
2210:
2211: SELECT intelligent_flag, start_date, end_date
2212: INTO l_intelligent_flag, l_start_date, l_end_date

Line 2247: cn_message_pkg.debug(

2243: l_primary_batch_stack(x_batch_total) := physical_rec.physical_batch_id;
2244: l_primary_request_stack(x_batch_total) := l_temp_id;
2245: l_current_phase_stack(x_batch_total) := l_curr_process;
2246:
2247: cn_message_pkg.debug(
2248: 'Submitted request for Physical Batch ' || physical_rec.physical_batch_id ||
2249: ' for process ' || l_curr_process || ' : Request = ' || l_temp_id
2250: );
2251:

Line 2303: cn_message_pkg.debug(

2299: DBMS_LOCK.sleep(l_sleep_time);
2300: END IF;
2301: */
2302:
2303: cn_message_pkg.debug(
2304: 'Check whether we can sleep for sometime to get the requests completed...'
2305: || ' Batch Total = ' || x_batch_total
2306: || ' : Reverted = ' || l_completed_revert_count
2307: || ' : Classified = ' || l_completed_classify_count

Line 2314: cn_message_pkg.debug('A new request has been submitted.. Lets check once more whether any other request has completed.');

2310: || ' : Calculated = ' || l_completed_calculate_count
2311: );
2312:
2313: IF l_new_request_submitted THEN
2314: cn_message_pkg.debug('A new request has been submitted.. Lets check once more whether any other request has completed.');
2315: l_new_request_submitted := FALSE;
2316: ELSE
2317: cn_message_pkg.debug('There is no change evident in this iteration. Therefore sleep for ' || l_sleep_time);
2318: DBMS_LOCK.sleep(l_sleep_time);

Line 2317: cn_message_pkg.debug('There is no change evident in this iteration. Therefore sleep for ' || l_sleep_time);

2313: IF l_new_request_submitted THEN
2314: cn_message_pkg.debug('A new request has been submitted.. Lets check once more whether any other request has completed.');
2315: l_new_request_submitted := FALSE;
2316: ELSE
2317: cn_message_pkg.debug('There is no change evident in this iteration. Therefore sleep for ' || l_sleep_time);
2318: DBMS_LOCK.sleep(l_sleep_time);
2319: END IF;
2320:
2321: FOR i IN 1 .. x_batch_total LOOP

Line 2347: cn_message_pkg.DEBUG('Concurrent Request#' || l_failed_request_id || ' for Physical Batch#' || l_temp_phys_batch_id || ' completed with error');

2343: , 'Request ' || l_failed_request_id || ' failed (batch_id = ' || l_temp_phys_batch_id
2344: );
2345: END IF;
2346:
2347: cn_message_pkg.DEBUG('Concurrent Request#' || l_failed_request_id || ' for Physical Batch#' || l_temp_phys_batch_id || ' completed with error');
2348: fnd_file.put_line(fnd_file.LOG, 'Conc_dispatch: Request completed with error for ' || l_failed_request_id);
2349: fnd_file.put_line(fnd_file.LOG, 'Conc_dispatch: Request failed for physical batch' || l_temp_phys_batch_id);
2350: RAISE conc_fail;
2351: END IF;

Line 2390: cn_message_pkg.DEBUG('Concurrent Request#' || l_failed_request_id || ' for Physical Batch#' || l_temp_phys_batch_id || ' completed with error');

2386: || l_temp_phys_batch_id
2387: );
2388: END IF;
2389:
2390: cn_message_pkg.DEBUG('Concurrent Request#' || l_failed_request_id || ' for Physical Batch#' || l_temp_phys_batch_id || ' completed with error');
2391: fnd_file.put_line(fnd_file.LOG, 'Conc_dispatch: Request completed with error for ' || l_failed_request_id);
2392: fnd_file.put_line(fnd_file.LOG, 'Conc_dispatch: Request failed for physical_batch' || l_temp_phys_batch_id);
2393: RAISE conc_fail;
2394: END IF; -- If error

Line 2449: cn_message_pkg.DEBUG('All concurrent requests complete phase ' || g_logical_process);

2445: next_process(x_physical_process => l_curr_process);
2446: END IF;
2447: ELSIF(l_current_phase_stack(primary_ptr) = g_calculation) THEN
2448: IF (l_completed_calculate_count = x_batch_total) THEN
2449: cn_message_pkg.DEBUG('All concurrent requests complete phase ' || g_logical_process);
2450: unfinished := FALSE;
2451: END IF;
2452: END IF;
2453:

Line 2468: cn_message_pkg.debug(

2464: l_primary_request_stack(primary_ptr) := l_temp_id;
2465: l_current_phase_stack(primary_ptr) := l_curr_process;
2466: l_new_request_submitted := TRUE;
2467:
2468: cn_message_pkg.debug(
2469: 'Moving Physical Batch#' || l_primary_batch_stack(primary_ptr) ||
2470: ' to next process ' || l_curr_process || ' Request = ' || l_temp_id
2471: );
2472:

Line 2508: cn_message_pkg.DEBUG('Cancelling request (ID=' || l_primary_request_stack(i)

2504: );
2505: END IF;
2506:
2507: l_call_status := fnd_concurrent.cancel_request(l_primary_request_stack(i), l_dummy);
2508: cn_message_pkg.DEBUG('Cancelling request (ID=' || l_primary_request_stack(i)
2509: || ' Status=' || l_dummy || ')');
2510: END IF;
2511: END LOOP;
2512: END IF;

Line 2514: cn_message_pkg.end_batch(x_parent_proc_audit_id);

2510: END IF;
2511: END LOOP;
2512: END IF;
2513:
2514: cn_message_pkg.end_batch(x_parent_proc_audit_id);
2515: WHEN OTHERS THEN
2516: IF (fnd_log.level_unexpected >= fnd_log.g_current_runtime_level) THEN
2517: fnd_log.STRING(fnd_log.level_unexpected
2518: , 'cn.plsql.cn_proc_batches_pkg.conc_dispatch.exception', SQLERRM);

Line 2522: cn_message_pkg.DEBUG('Exception occurs in cn_proc_batches_pkg.conc_dispatch:');

2518: , 'cn.plsql.cn_proc_batches_pkg.conc_dispatch.exception', SQLERRM);
2519: END IF;
2520:
2521: fnd_file.put_line(fnd_file.LOG, 'unexpected exception in cn_proc_batches_pkg.conc_dispatch');
2522: cn_message_pkg.DEBUG('Exception occurs in cn_proc_batches_pkg.conc_dispatch:');
2523: cn_message_pkg.rollback_errormsg_commit(SQLERRM);
2524: RAISE;
2525: END conc_dispatch;
2526:

Line 2523: cn_message_pkg.rollback_errormsg_commit(SQLERRM);

2519: END IF;
2520:
2521: fnd_file.put_line(fnd_file.LOG, 'unexpected exception in cn_proc_batches_pkg.conc_dispatch');
2522: cn_message_pkg.DEBUG('Exception occurs in cn_proc_batches_pkg.conc_dispatch:');
2523: cn_message_pkg.rollback_errormsg_commit(SQLERRM);
2524: RAISE;
2525: END conc_dispatch;
2526:
2527: PROCEDURE conc_dispatch2(x_parent_proc_audit_id NUMBER) IS

Line 2620: cn_message_pkg.FLUSH;

2616: , 'Beginning of conc_dispatch2...'
2617: );
2618: END IF;
2619:
2620: cn_message_pkg.FLUSH;
2621: COMMIT;
2622:
2623: SELECT intelligent_flag, start_date, end_date
2624: INTO l_intelligent_flag, l_start_date, l_end_date

Line 2735: cn_message_pkg.DEBUG('Concurrent request completed with error (request ID='

2731: , 'Request ' || l_failed_request_id || ' failed (batch_id = ' || l_temp_phys_batch_id
2732: );
2733: END IF;
2734:
2735: cn_message_pkg.DEBUG('Concurrent request completed with error (request ID='
2736: || l_failed_request_id || ')');
2737: cn_message_pkg.DEBUG('(physical batch ID=' || l_temp_phys_batch_id || ')');
2738: fnd_file.put_line(
2739: fnd_file.LOG

Line 2737: cn_message_pkg.DEBUG('(physical batch ID=' || l_temp_phys_batch_id || ')');

2733: END IF;
2734:
2735: cn_message_pkg.DEBUG('Concurrent request completed with error (request ID='
2736: || l_failed_request_id || ')');
2737: cn_message_pkg.DEBUG('(physical batch ID=' || l_temp_phys_batch_id || ')');
2738: fnd_file.put_line(
2739: fnd_file.LOG
2740: , 'Conc_dispatch2: Request completed with error for ' || l_failed_request_id
2741: );

Line 2786: cn_message_pkg.DEBUG('Concurrent request completed with error (request ID='

2782: || l_temp_phys_batch_id
2783: );
2784: END IF;
2785:
2786: cn_message_pkg.DEBUG('Concurrent request completed with error (request ID='
2787: || l_failed_request_id || ')');
2788: cn_message_pkg.DEBUG('(physical batch ID=' || l_temp_phys_batch_id || ')');
2789: fnd_file.put_line(
2790: fnd_file.LOG

Line 2788: cn_message_pkg.DEBUG('(physical batch ID=' || l_temp_phys_batch_id || ')');

2784: END IF;
2785:
2786: cn_message_pkg.DEBUG('Concurrent request completed with error (request ID='
2787: || l_failed_request_id || ')');
2788: cn_message_pkg.DEBUG('(physical batch ID=' || l_temp_phys_batch_id || ')');
2789: fnd_file.put_line(
2790: fnd_file.LOG
2791: , 'Conc_dispatch2: Request completed with error for ' || l_failed_request_id
2792: );

Line 2853: cn_message_pkg.DEBUG('All requests complete phase ' || g_logical_process);

2849: next_process(x_physical_process => l_curr_process);
2850: END IF;
2851: ELSIF(l_current_phase_stack(primary_ptr) = g_calculation) THEN
2852: IF (l_completed_calculate_count = g_batch_total) THEN
2853: cn_message_pkg.DEBUG('All requests complete phase ' || g_logical_process);
2854: unfinished := FALSE;
2855: END IF;
2856: END IF;
2857:

Line 2872: cn_message_pkg.debug(

2868: l_primary_request_stack(primary_ptr) := l_temp_id;
2869: l_current_phase_stack(primary_ptr) := l_curr_process;
2870: l_new_request_submitted := TRUE;
2871:
2872: cn_message_pkg.debug(
2873: 'Moving Physical Batch#' || l_primary_batch_stack(primary_ptr) ||
2874: ' to next process ' || l_curr_process || ' Request = ' || l_temp_id
2875: );
2876:

Line 2904: cn_message_pkg.debug(

2900: DBMS_LOCK.sleep(l_sleep_time);
2901: END IF;
2902: */
2903:
2904: cn_message_pkg.debug(
2905: 'Check whether we can sleep for sometime to get the requests completed...'
2906: || ' Batch Total = ' || g_batch_total
2907: || ' : Reverted = ' || l_completed_revert_count
2908: || ' : Classified = ' || l_completed_classify_count

Line 2915: cn_message_pkg.debug('A new request has been submitted.. Lets check once more whether any other request has completed.');

2911: || ' : Calculated = ' || l_completed_calculate_count
2912: );
2913:
2914: IF l_new_request_submitted THEN
2915: cn_message_pkg.debug('A new request has been submitted.. Lets check once more whether any other request has completed.');
2916: l_new_request_submitted := FALSE;
2917: ELSE
2918: cn_message_pkg.debug('There is no change evident in this iteration. Therefore sleep for ' || l_sleep_time);
2919: DBMS_LOCK.sleep(l_sleep_time);

Line 2918: cn_message_pkg.debug('There is no change evident in this iteration. Therefore sleep for ' || l_sleep_time);

2914: IF l_new_request_submitted THEN
2915: cn_message_pkg.debug('A new request has been submitted.. Lets check once more whether any other request has completed.');
2916: l_new_request_submitted := FALSE;
2917: ELSE
2918: cn_message_pkg.debug('There is no change evident in this iteration. Therefore sleep for ' || l_sleep_time);
2919: DBMS_LOCK.sleep(l_sleep_time);
2920: END IF;
2921:
2922: END LOOP;

Line 2949: cn_message_pkg.DEBUG(

2945: );
2946: END IF;
2947:
2948: l_call_status := fnd_concurrent.cancel_request(l_primary_request_stack(i), l_dummy1);
2949: cn_message_pkg.DEBUG(
2950: 'Cancelling request (ID=' || l_primary_request_stack(i) || ' Status=' || l_dummy1
2951: || ')'
2952: );
2953: END IF;

Line 2957: cn_message_pkg.DEBUG('Concurrent request failed (physical batch ID=' || l_temp_phys_batch_id

2953: END IF;
2954: END LOOP;
2955: END IF;
2956:
2957: cn_message_pkg.DEBUG('Concurrent request failed (physical batch ID=' || l_temp_phys_batch_id
2958: || ')');
2959: cn_message_pkg.end_batch(x_parent_proc_audit_id);
2960: WHEN OTHERS THEN
2961: IF (fnd_log.level_unexpected >= fnd_log.g_current_runtime_level) THEN

Line 2959: cn_message_pkg.end_batch(x_parent_proc_audit_id);

2955: END IF;
2956:
2957: cn_message_pkg.DEBUG('Concurrent request failed (physical batch ID=' || l_temp_phys_batch_id
2958: || ')');
2959: cn_message_pkg.end_batch(x_parent_proc_audit_id);
2960: WHEN OTHERS THEN
2961: IF (fnd_log.level_unexpected >= fnd_log.g_current_runtime_level) THEN
2962: fnd_log.STRING(
2963: fnd_log.level_unexpected

Line 2970: cn_message_pkg.DEBUG('Exception occurs in cn_proc_batches_pkg.conc_dispatch2:');

2966: );
2967: END IF;
2968:
2969: fnd_file.put_line(fnd_file.LOG, 'unexpected exception in cn_proc_batches_pkg.conc_dispatch');
2970: cn_message_pkg.DEBUG('Exception occurs in cn_proc_batches_pkg.conc_dispatch2:');
2971: cn_message_pkg.rollback_errormsg_commit(SQLERRM);
2972: RAISE;
2973: END conc_dispatch2;
2974:

Line 2971: cn_message_pkg.rollback_errormsg_commit(SQLERRM);

2967: END IF;
2968:
2969: fnd_file.put_line(fnd_file.LOG, 'unexpected exception in cn_proc_batches_pkg.conc_dispatch');
2970: cn_message_pkg.DEBUG('Exception occurs in cn_proc_batches_pkg.conc_dispatch2:');
2971: cn_message_pkg.rollback_errormsg_commit(SQLERRM);
2972: RAISE;
2973: END conc_dispatch2;
2974:
2975: -- Procedure Name

Line 3012: cn_message_pkg.FLUSH;

3008: FETCH bc INTO g_batch_total;
3009: CLOSE bc;
3010:
3011: flood_rev_classes;
3012: cn_message_pkg.FLUSH;
3013: COMMIT;
3014:
3015: WHILE NOT finished LOOP
3016: IF g_calc_type = 'BONUS' THEN

Line 3069: cn_message_pkg.DEBUG('Exception occurs in cn_proc_batches.seq_dispatch:');

3065: fnd_log.STRING(fnd_log.level_unexpected
3066: , 'cn.plsql.cn_proc_batches_pkg.seq_dispatch.exception', SQLERRM);
3067: END IF;
3068:
3069: cn_message_pkg.DEBUG('Exception occurs in cn_proc_batches.seq_dispatch:');
3070: cn_message_pkg.rollback_errormsg_commit(SQLERRM);
3071: RAISE;
3072: END seq_dispatch;
3073:

Line 3070: cn_message_pkg.rollback_errormsg_commit(SQLERRM);

3066: , 'cn.plsql.cn_proc_batches_pkg.seq_dispatch.exception', SQLERRM);
3067: END IF;
3068:
3069: cn_message_pkg.DEBUG('Exception occurs in cn_proc_batches.seq_dispatch:');
3070: cn_message_pkg.rollback_errormsg_commit(SQLERRM);
3071: RAISE;
3072: END seq_dispatch;
3073:
3074: /* ----------------------------------------------------------------------------

Line 3103: cn_message_pkg.begin_batch(

3099: INTO l_org_id
3100: FROM cn_calc_submission_batches
3101: WHERE calc_sub_batch_id = p_calc_sub_batch_id;
3102:
3103: cn_message_pkg.begin_batch(
3104: x_process_type => 'CALCULATION'
3105: , x_parent_proc_audit_id => l_process_audit_id
3106: , x_process_audit_id => l_process_audit_id
3107: , x_request_id => fnd_global.conc_request_id

Line 3111: cn_message_pkg.DEBUG('Beginning of calculate_batch...');

3107: , x_request_id => fnd_global.conc_request_id
3108: , p_org_id => l_org_id
3109: );
3110: fnd_file.put_line(fnd_file.LOG, 'Beginning of calculate_batch...');
3111: cn_message_pkg.DEBUG('Beginning of calculate_batch...');
3112:
3113: UPDATE cn_calc_submission_batches_all
3114: SET process_audit_id = l_process_audit_id,
3115: status='PROCESSING'

Line 3133: cn_message_pkg.DEBUG(l_msg_data);

3129: IF l_return_status <> fnd_api.g_ret_sts_success THEN
3130: FOR l_counter IN 1 .. l_msg_count LOOP
3131: l_msg_data := fnd_msg_pub.get(p_msg_index => l_counter, p_encoded => fnd_api.g_false);
3132: fnd_file.put_line(fnd_file.LOG, l_msg_data);
3133: cn_message_pkg.DEBUG(l_msg_data);
3134: END LOOP;
3135:
3136: retcode := 2;
3137: errbuf := l_msg_data;

Line 3149: cn_message_pkg.DEBUG('End of the calculation process.');

3145: );
3146: END IF;
3147:
3148: fnd_file.put_line(fnd_file.LOG, 'End of the calculation process.');
3149: cn_message_pkg.DEBUG('End of the calculation process.');
3150: cn_message_pkg.end_batch(l_process_audit_id);
3151: EXCEPTION
3152: WHEN OTHERS THEN
3153: retcode := 2;

Line 3150: cn_message_pkg.end_batch(l_process_audit_id);

3146: END IF;
3147:
3148: fnd_file.put_line(fnd_file.LOG, 'End of the calculation process.');
3149: cn_message_pkg.DEBUG('End of the calculation process.');
3150: cn_message_pkg.end_batch(l_process_audit_id);
3151: EXCEPTION
3152: WHEN OTHERS THEN
3153: retcode := 2;
3154: errbuf := SQLERRM;

Line 3164: cn_message_pkg.end_batch(l_process_audit_id);

3160: , SQLERRM
3161: );
3162: END IF;
3163:
3164: cn_message_pkg.end_batch(l_process_audit_id);
3165: END calculate_batch;
3166:
3167: PROCEDURE calc(
3168: errbuf OUT NOCOPY VARCHAR2

Line 3510: cn_message_pkg.begin_batch(

3506:
3507: l_request_id := fnd_global.conc_request_id;
3508:
3509: IF l_request_id <> -1 THEN
3510: cn_message_pkg.begin_batch(
3511: x_process_type => 'CALCULATION'
3512: , x_parent_proc_audit_id => p_parent_proc_audit_id
3513: , x_process_audit_id => l_process_audit_id
3514: , x_request_id => fnd_global.conc_request_id

Line 3519: cn_message_pkg.DEBUG(

3515: , p_org_id => l_org_id
3516: );
3517: END IF;
3518:
3519: cn_message_pkg.DEBUG(
3520: 'Start batch runner (phase=' || p_physical_process || ', batch ID=' || p_physical_batch_id
3521: || ')'
3522: );
3523: cn_proc_batches_pkg.process_status(

Line 3565: cn_message_pkg.DEBUG('Exception occurs in classification process:');

3561: , p_physical_batch_id => p_physical_batch_id
3562: );
3563:
3564: IF l_return_status <> fnd_api.g_ret_sts_success THEN
3565: cn_message_pkg.DEBUG('Exception occurs in classification process:');
3566:
3567: FOR l_counter IN 1 .. l_msg_count LOOP
3568: cn_message_pkg.DEBUG(fnd_msg_pub.get(p_msg_index => l_counter
3569: , p_encoded => fnd_api.g_false));

Line 3568: cn_message_pkg.DEBUG(fnd_msg_pub.get(p_msg_index => l_counter

3564: IF l_return_status <> fnd_api.g_ret_sts_success THEN
3565: cn_message_pkg.DEBUG('Exception occurs in classification process:');
3566:
3567: FOR l_counter IN 1 .. l_msg_count LOOP
3568: cn_message_pkg.DEBUG(fnd_msg_pub.get(p_msg_index => l_counter
3569: , p_encoded => fnd_api.g_false));
3570: END LOOP;
3571:
3572: RAISE api_call_failed;

Line 3586: cn_message_pkg.DEBUG('Exception occurs in rollup phase:');

3582: , p_physical_batch_id => p_physical_batch_id
3583: );
3584:
3585: IF l_return_status <> fnd_api.g_ret_sts_success THEN
3586: cn_message_pkg.DEBUG('Exception occurs in rollup phase:');
3587:
3588: FOR l_counter IN 1 .. l_msg_count LOOP
3589: cn_message_pkg.DEBUG(fnd_msg_pub.get(p_msg_index => l_counter
3590: , p_encoded => fnd_api.g_false));

Line 3589: cn_message_pkg.DEBUG(fnd_msg_pub.get(p_msg_index => l_counter

3585: IF l_return_status <> fnd_api.g_ret_sts_success THEN
3586: cn_message_pkg.DEBUG('Exception occurs in rollup phase:');
3587:
3588: FOR l_counter IN 1 .. l_msg_count LOOP
3589: cn_message_pkg.DEBUG(fnd_msg_pub.get(p_msg_index => l_counter
3590: , p_encoded => fnd_api.g_false));
3591: END LOOP;
3592:
3593: RAISE api_call_failed;

Line 3607: cn_message_pkg.DEBUG('Exception occurs in population phase:');

3603: , p_physical_batch_id => p_physical_batch_id
3604: );
3605:
3606: IF l_return_status <> fnd_api.g_ret_sts_success THEN
3607: cn_message_pkg.DEBUG('Exception occurs in population phase:');
3608:
3609: FOR l_counter IN 1 .. l_msg_count LOOP
3610: cn_message_pkg.DEBUG(fnd_msg_pub.get(p_msg_index => l_counter
3611: , p_encoded => fnd_api.g_false));

Line 3610: cn_message_pkg.DEBUG(fnd_msg_pub.get(p_msg_index => l_counter

3606: IF l_return_status <> fnd_api.g_ret_sts_success THEN
3607: cn_message_pkg.DEBUG('Exception occurs in population phase:');
3608:
3609: FOR l_counter IN 1 .. l_msg_count LOOP
3610: cn_message_pkg.DEBUG(fnd_msg_pub.get(p_msg_index => l_counter
3611: , p_encoded => fnd_api.g_false));
3612: END LOOP;
3613:
3614: RAISE api_call_failed;

Line 3621: cn_message_pkg.DEBUG(

3617: cn_global_var.initialize_instance_info(l_org_id);
3618: cn_formula_common_pkg.calculate_batch(p_physical_batch_id);
3619: END IF;
3620:
3621: cn_message_pkg.DEBUG(
3622: 'Complete batch runner (phase='
3623: || p_physical_process
3624: || ', batch ID='
3625: || p_physical_batch_id

Line 3670: cn_message_pkg.FLUSH;

3666: AND per.period_set_id = l_period_set_id
3667: AND per.period_type_id = l_period_type_id);
3668: END IF;
3669:
3670: cn_message_pkg.FLUSH;
3671: COMMIT;
3672:
3673: -- If run as a conc program it will have its own process audit id
3674: -- and request id therefore we need to give info on the process

Line 3676: cn_message_pkg.end_batch(l_process_audit_id);

3672:
3673: -- If run as a conc program it will have its own process audit id
3674: -- and request id therefore we need to give info on the process
3675: IF l_request_id <> -1 THEN
3676: cn_message_pkg.end_batch(l_process_audit_id);
3677: END IF;
3678:
3679: retcode := 0;
3680: errbuf := 'Batch runner completes successfully.';

Line 3693: cn_message_pkg.DEBUG('Time is ' || TO_CHAR(SYSDATE, 'DD-MON-YY HH24:MI:SS'));

3689: || TO_CHAR(SYSDATE, 'DD-MON-YY HH24:MI:SS')
3690: );
3691: END IF;
3692:
3693: cn_message_pkg.DEBUG('Time is ' || TO_CHAR(SYSDATE, 'DD-MON-YY HH24:MI:SS'));
3694: fnd_file.put_line(fnd_file.LOG, 'Time is ' || TO_CHAR(SYSDATE, 'DD-MON-YY HH24:MI:SS'));
3695: EXCEPTION
3696: WHEN api_call_failed THEN
3697: retcode := 2;

Line 3707: cn_message_pkg.rollback_errormsg_commit('Exception occurs in batch runner (ID='

3703: , fnd_msg_pub.get(p_msg_index => l_counter, p_encoded => fnd_api.g_false));
3704: END LOOP;
3705: END IF;
3706:
3707: cn_message_pkg.rollback_errormsg_commit('Exception occurs in batch runner (ID='
3708: || p_physical_batch_id || ')');
3709: update_error(p_physical_batch_id);
3710:
3711: -- if concurrent program, commit and close log file

Line 3714: cn_message_pkg.end_batch(l_process_audit_id);

3710:
3711: -- if concurrent program, commit and close log file
3712: -- if sequential calcualtion, commit and leave log file open
3713: IF l_request_id <> -1 THEN
3714: cn_message_pkg.end_batch(l_process_audit_id);
3715: ELSE
3716: COMMIT;
3717: END IF;
3718: WHEN OTHERS THEN

Line 3724: cn_message_pkg.DEBUG('Exception occurs in batch runner (ID=' || p_physical_batch_id || ')');

3720: retcode := 2;
3721: errbuf := SQLERRM;
3722: -- to make sure we record the updates made by update_error
3723: -- we roll back first
3724: cn_message_pkg.DEBUG('Exception occurs in batch runner (ID=' || p_physical_batch_id || ')');
3725: cn_message_pkg.rollback_errormsg_commit(errbuf);
3726: update_error(p_physical_batch_id);
3727:
3728: -- if concurrent program, commit and close log file

Line 3725: cn_message_pkg.rollback_errormsg_commit(errbuf);

3721: errbuf := SQLERRM;
3722: -- to make sure we record the updates made by update_error
3723: -- we roll back first
3724: cn_message_pkg.DEBUG('Exception occurs in batch runner (ID=' || p_physical_batch_id || ')');
3725: cn_message_pkg.rollback_errormsg_commit(errbuf);
3726: update_error(p_physical_batch_id);
3727:
3728: -- if concurrent program, commit and close log file
3729: -- if sequential calcualtion, commit and leave log file open

Line 3731: cn_message_pkg.end_batch(l_process_audit_id);

3727:
3728: -- if concurrent program, commit and close log file
3729: -- if sequential calcualtion, commit and leave log file open
3730: IF l_request_id <> -1 THEN
3731: cn_message_pkg.end_batch(l_process_audit_id);
3732: ELSE
3733: COMMIT;
3734: END IF;
3735:

Line 3781: cn_message_pkg.DEBUG(

3777: END IF;
3778: END LOOP;
3779:
3780: IF x_covered = FALSE THEN
3781: cn_message_pkg.DEBUG(
3782: 'No classification ruleset is defined for the period from '
3783: || p_start_date
3784: || ' to '
3785: || p_end_date

Line 3833: cn_message_pkg.DEBUG('Please synchronize ruleset (Name=' || l_set.NAME || ')');

3829: END IF;
3830:
3831: FOR l_set IN l_rulesets_csr LOOP
3832: IF l_set.ruleset_status IN('UNSYNC', 'INSTINPG', 'INSTFAIL', 'CONCFAIL') THEN
3833: cn_message_pkg.DEBUG('Please synchronize ruleset (Name=' || l_set.NAME || ')');
3834: l_error_ctr := 1;
3835: ELSE
3836: l_cls_pkg_name := 'cn_clsfn_' || TO_CHAR(ABS(l_set.ruleset_id)) || cached_org_append;
3837:

Line 3843: cn_message_pkg.DEBUG('Please synchronize ruleset (name=' || l_set.NAME || ')');

3839: FETCH l_chk_rule_package_csr INTO l_counter;
3840: CLOSE l_chk_rule_package_csr;
3841:
3842: IF l_counter = 0 THEN
3843: cn_message_pkg.DEBUG('Please synchronize ruleset (name=' || l_set.NAME || ')');
3844: cn_message_pkg.DEBUG('Classification package is missing (name=' || l_cls_pkg_name || ')');
3845: l_error_ctr := 1;
3846: END IF;
3847: END IF;

Line 3844: cn_message_pkg.DEBUG('Classification package is missing (name=' || l_cls_pkg_name || ')');

3840: CLOSE l_chk_rule_package_csr;
3841:
3842: IF l_counter = 0 THEN
3843: cn_message_pkg.DEBUG('Please synchronize ruleset (name=' || l_set.NAME || ')');
3844: cn_message_pkg.DEBUG('Classification package is missing (name=' || l_cls_pkg_name || ')');
3845: l_error_ctr := 1;
3846: END IF;
3847: END IF;
3848: END LOOP;

Line 3925: cn_message_pkg.begin_batch(

3921: -- calc submission form.
3922: -- If it is a conc request and was submitted from the form then
3923: -- we will already have the process audit id
3924: IF l_request_id <> -1 THEN
3925: cn_message_pkg.begin_batch(
3926: x_process_type => 'CALCULATION'
3927: , x_parent_proc_audit_id => p_parent_proc_audit_id
3928: , x_process_audit_id => l_process_audit_id
3929: , x_request_id => fnd_global.conc_request_id

Line 4001: cn_message_pkg.end_batch(l_paid);

3997: void_batches(NULL);
3998: END IF;
3999:
4000: <>
4001: cn_message_pkg.end_batch(l_paid);
4002: EXCEPTION
4003: WHEN OTHERS THEN
4004: retcode := 2;
4005: errbuf := SQLERRM;

Line 4008: cn_message_pkg.DEBUG('Exception occurs in cn_proc_batches_pkg.processor:');

4004: retcode := 2;
4005: errbuf := SQLERRM;
4006: fnd_file.put_line(fnd_file.LOG, 'Unexpected exception in cn_proc_batches_pkg.processor');
4007: fnd_file.put_line(fnd_file.LOG, SQLERRM);
4008: cn_message_pkg.DEBUG('Exception occurs in cn_proc_batches_pkg.processor:');
4009: cn_message_pkg.rollback_errormsg_commit(errbuf);
4010: cn_calc_sub_batches_pkg.update_calc_sub_batch(g_logical_batch_id, 'FAILED');
4011: cn_message_pkg.end_batch(l_paid);
4012:

Line 4009: cn_message_pkg.rollback_errormsg_commit(errbuf);

4005: errbuf := SQLERRM;
4006: fnd_file.put_line(fnd_file.LOG, 'Unexpected exception in cn_proc_batches_pkg.processor');
4007: fnd_file.put_line(fnd_file.LOG, SQLERRM);
4008: cn_message_pkg.DEBUG('Exception occurs in cn_proc_batches_pkg.processor:');
4009: cn_message_pkg.rollback_errormsg_commit(errbuf);
4010: cn_calc_sub_batches_pkg.update_calc_sub_batch(g_logical_batch_id, 'FAILED');
4011: cn_message_pkg.end_batch(l_paid);
4012:
4013: IF (fnd_log.level_unexpected >= fnd_log.g_current_runtime_level) THEN

Line 4011: cn_message_pkg.end_batch(l_paid);

4007: fnd_file.put_line(fnd_file.LOG, SQLERRM);
4008: cn_message_pkg.DEBUG('Exception occurs in cn_proc_batches_pkg.processor:');
4009: cn_message_pkg.rollback_errormsg_commit(errbuf);
4010: cn_calc_sub_batches_pkg.update_calc_sub_batch(g_logical_batch_id, 'FAILED');
4011: cn_message_pkg.end_batch(l_paid);
4012:
4013: IF (fnd_log.level_unexpected >= fnd_log.g_current_runtime_level) THEN
4014: fnd_log.STRING(fnd_log.level_unexpected
4015: , 'cn.plsql.cn_proc_batches_pkg.processor.exception', SQLERRM);

Line 4079: cn_message_pkg.begin_batch(

4075: COMMIT;
4076:
4077: -- The process audit_id is passed in when called from the trx form.
4078: IF x_process_audit_id IS NULL THEN
4079: cn_message_pkg.begin_batch(
4080: x_process_type => 'CALCULATION'
4081: , x_parent_proc_audit_id => NULL
4082: , x_process_audit_id => x_process_audit_id
4083: , x_request_id => fnd_global.conc_request_id

Line 4105: cn_message_pkg.DEBUG('Invalid process code (' || p_process_name || ')');

4101: END IF;
4102: ELSE
4103: fnd_file.put_line(fnd_file.LOG
4104: , 'cn_proc_batches_pkg.main: bad process name: ' || p_process_name);
4105: cn_message_pkg.DEBUG('Invalid process code (' || p_process_name || ')');
4106: RAISE ABORT;
4107: END IF;
4108:
4109: IF NVL(cn_global_var.g_system_batch_size, 0) = 0 THEN

Line 4110: cn_message_pkg.set_name('CN', 'PROC_BAD_BATCH_SIZE');

4106: RAISE ABORT;
4107: END IF;
4108:
4109: IF NVL(cn_global_var.g_system_batch_size, 0) = 0 THEN
4110: cn_message_pkg.set_name('CN', 'PROC_BAD_BATCH_SIZE');
4111: fnd_file.put_line(fnd_file.LOG, fnd_message.get);
4112: RAISE ABORT;
4113: END IF;
4114:

Line 4124: cn_message_pkg.DEBUG('Start processing transactions (non concurrent calculation)');

4120: );
4121: END IF;
4122:
4123: IF (p_concurrent_flag = 'N' OR(p_concurrent_flag = 'Y' AND fnd_global.conc_program_id <> -1)) THEN
4124: cn_message_pkg.DEBUG('Start processing transactions (non concurrent calculation)');
4125: cn_proc_batches_pkg.processor(
4126: l_dummy
4127: , l_temp
4128: , x_process_audit_id

Line 4137: cn_message_pkg.DEBUG('End processing transactions (non concurrent calculation)');

4133: , p_end_date
4134: , p_salesrep_id
4135: , p_comp_plan_id
4136: );
4137: cn_message_pkg.DEBUG('End processing transactions (non concurrent calculation)');
4138:
4139: IF (l_temp = 2) THEN
4140: x_process_status_code := 'FAIL';
4141: ELSE

Line 4152: --cn_message_pkg.set_name('CN','ALL_PROCESS_DONE_OK');

4148: WHERE logical_batch_id = p_logical_batch_id AND status_code = 'ERROR');
4149:
4150: cn_calc_sub_batches_pkg.update_calc_sub_batch(g_logical_batch_id, 'COMPLETE');
4151: x_process_status_code := 'SUCCESS';
4152: --cn_message_pkg.set_name('CN','ALL_PROCESS_DONE_OK');
4153: cn_message_pkg.end_batch(x_process_audit_id);
4154: EXCEPTION
4155: WHEN NO_DATA_FOUND THEN
4156: cn_calc_sub_batches_pkg.update_calc_sub_batch(g_logical_batch_id, 'FAILED');

Line 4153: cn_message_pkg.end_batch(x_process_audit_id);

4149:
4150: cn_calc_sub_batches_pkg.update_calc_sub_batch(g_logical_batch_id, 'COMPLETE');
4151: x_process_status_code := 'SUCCESS';
4152: --cn_message_pkg.set_name('CN','ALL_PROCESS_DONE_OK');
4153: cn_message_pkg.end_batch(x_process_audit_id);
4154: EXCEPTION
4155: WHEN NO_DATA_FOUND THEN
4156: cn_calc_sub_batches_pkg.update_calc_sub_batch(g_logical_batch_id, 'FAILED');
4157: x_process_status_code := 'FAIL';

Line 4158: --cn_message_pkg.set_name('CN','ALL_PROCESS_DONE_FAIL');

4154: EXCEPTION
4155: WHEN NO_DATA_FOUND THEN
4156: cn_calc_sub_batches_pkg.update_calc_sub_batch(g_logical_batch_id, 'FAILED');
4157: x_process_status_code := 'FAIL';
4158: --cn_message_pkg.set_name('CN','ALL_PROCESS_DONE_FAIL');
4159: cn_message_pkg.end_batch(x_process_audit_id);
4160: END;
4161:
4162: COMMIT;

Line 4159: cn_message_pkg.end_batch(x_process_audit_id);

4155: WHEN NO_DATA_FOUND THEN
4156: cn_calc_sub_batches_pkg.update_calc_sub_batch(g_logical_batch_id, 'FAILED');
4157: x_process_status_code := 'FAIL';
4158: --cn_message_pkg.set_name('CN','ALL_PROCESS_DONE_FAIL');
4159: cn_message_pkg.end_batch(x_process_audit_id);
4160: END;
4161:
4162: COMMIT;
4163: END IF;

Line 4189: cn_message_pkg.DEBUG('Failed to submit concurrent request (Batch Processor)');

4185:
4186: IF l_request_id = 0 THEN
4187: fnd_file.put_line(fnd_file.LOG
4188: , 'cn_proc_batches_pkg.main: unable to submit batch_processor');
4189: cn_message_pkg.DEBUG('Failed to submit concurrent request (Batch Processor)');
4190: cn_message_pkg.DEBUG(fnd_message.get);
4191: x_process_status_code := 'FAIL';
4192:
4193: IF (fnd_log.level_unexpected >= fnd_log.g_current_runtime_level) THEN

Line 4190: cn_message_pkg.DEBUG(fnd_message.get);

4186: IF l_request_id = 0 THEN
4187: fnd_file.put_line(fnd_file.LOG
4188: , 'cn_proc_batches_pkg.main: unable to submit batch_processor');
4189: cn_message_pkg.DEBUG('Failed to submit concurrent request (Batch Processor)');
4190: cn_message_pkg.DEBUG(fnd_message.get);
4191: x_process_status_code := 'FAIL';
4192:
4193: IF (fnd_log.level_unexpected >= fnd_log.g_current_runtime_level) THEN
4194: fnd_log.STRING(

Line 4206: cn_message_pkg.end_batch(x_process_audit_id);

4202: ELSE
4203: x_process_status_code := 'SUCCESS';
4204: -- a separate process is being called so we need to wrap up this
4205: -- batch of messages
4206: cn_message_pkg.end_batch(x_process_audit_id);
4207: -- for concurrent request, it makes more sense to return request_id.
4208: -- It is better to use another parameter to return request_id.
4209: x_process_audit_id := l_request_id;
4210: cn_message_pkg.FLUSH;

Line 4210: cn_message_pkg.FLUSH;

4206: cn_message_pkg.end_batch(x_process_audit_id);
4207: -- for concurrent request, it makes more sense to return request_id.
4208: -- It is better to use another parameter to return request_id.
4209: x_process_audit_id := l_request_id;
4210: cn_message_pkg.FLUSH;
4211: COMMIT;
4212: END IF;
4213: END IF;
4214:

Line 4232: cn_message_pkg.rollback_errormsg_commit('Exception occurs in cn_proc_batches_pkg.main.');

4228: );
4229: END IF;
4230: EXCEPTION
4231: WHEN ABORT THEN
4232: cn_message_pkg.rollback_errormsg_commit('Exception occurs in cn_proc_batches_pkg.main.');
4233: cn_calc_sub_batches_pkg.update_calc_sub_batch(g_logical_batch_id, 'FAILED');
4234: COMMIT;
4235: x_process_status_code := 'FAIL';
4236: fnd_file.put_line(fnd_file.LOG, fnd_message.get);

Line 4237: cn_message_pkg.end_batch(x_process_audit_id);

4233: cn_calc_sub_batches_pkg.update_calc_sub_batch(g_logical_batch_id, 'FAILED');
4234: COMMIT;
4235: x_process_status_code := 'FAIL';
4236: fnd_file.put_line(fnd_file.LOG, fnd_message.get);
4237: cn_message_pkg.end_batch(x_process_audit_id);
4238: WHEN OTHERS THEN
4239: fnd_file.put_line(fnd_file.LOG, 'unexpected exception in cn_proc_batches_pkg.main');
4240: fnd_file.put_line(fnd_file.LOG, SQLERRM);
4241: cn_message_pkg.DEBUG('Exception occurs in cn_proc_batches_pkg.main: ');

Line 4241: cn_message_pkg.DEBUG('Exception occurs in cn_proc_batches_pkg.main: ');

4237: cn_message_pkg.end_batch(x_process_audit_id);
4238: WHEN OTHERS THEN
4239: fnd_file.put_line(fnd_file.LOG, 'unexpected exception in cn_proc_batches_pkg.main');
4240: fnd_file.put_line(fnd_file.LOG, SQLERRM);
4241: cn_message_pkg.DEBUG('Exception occurs in cn_proc_batches_pkg.main: ');
4242: cn_message_pkg.rollback_errormsg_commit(SQLERRM);
4243: cn_calc_sub_batches_pkg.update_calc_sub_batch(g_logical_batch_id, 'FAILED');
4244: COMMIT;
4245: x_process_status_code := 'FAIL';

Line 4242: cn_message_pkg.rollback_errormsg_commit(SQLERRM);

4238: WHEN OTHERS THEN
4239: fnd_file.put_line(fnd_file.LOG, 'unexpected exception in cn_proc_batches_pkg.main');
4240: fnd_file.put_line(fnd_file.LOG, SQLERRM);
4241: cn_message_pkg.DEBUG('Exception occurs in cn_proc_batches_pkg.main: ');
4242: cn_message_pkg.rollback_errormsg_commit(SQLERRM);
4243: cn_calc_sub_batches_pkg.update_calc_sub_batch(g_logical_batch_id, 'FAILED');
4244: COMMIT;
4245: x_process_status_code := 'FAIL';
4246: --cn_message_pkg.set_name('CN','ALL_PROCESS_DONE_FAIL');

Line 4246: --cn_message_pkg.set_name('CN','ALL_PROCESS_DONE_FAIL');

4242: cn_message_pkg.rollback_errormsg_commit(SQLERRM);
4243: cn_calc_sub_batches_pkg.update_calc_sub_batch(g_logical_batch_id, 'FAILED');
4244: COMMIT;
4245: x_process_status_code := 'FAIL';
4246: --cn_message_pkg.set_name('CN','ALL_PROCESS_DONE_FAIL');
4247: cn_message_pkg.end_batch(x_process_audit_id);
4248:
4249: IF (fnd_log.level_unexpected >= fnd_log.g_current_runtime_level) THEN
4250: fnd_log.STRING(fnd_log.level_unexpected, 'cn.plsql.cn_proc_batches_pkg.main.exception'

Line 4247: cn_message_pkg.end_batch(x_process_audit_id);

4243: cn_calc_sub_batches_pkg.update_calc_sub_batch(g_logical_batch_id, 'FAILED');
4244: COMMIT;
4245: x_process_status_code := 'FAIL';
4246: --cn_message_pkg.set_name('CN','ALL_PROCESS_DONE_FAIL');
4247: cn_message_pkg.end_batch(x_process_audit_id);
4248:
4249: IF (fnd_log.level_unexpected >= fnd_log.g_current_runtime_level) THEN
4250: fnd_log.STRING(fnd_log.level_unexpected, 'cn.plsql.cn_proc_batches_pkg.main.exception'
4251: , SQLERRM);

Line 4887: cn_message_pkg.DEBUG('Exception occurs in cn_proc_batches_pkg.populate_bonus_process_batch:');

4883: );
4884: END IF;
4885: EXCEPTION
4886: WHEN no_comm_lines THEN
4887: cn_message_pkg.DEBUG('Exception occurs in cn_proc_batches_pkg.populate_bonus_process_batch:');
4888: cn_message_pkg.rollback_errormsg_commit
4889: (
4890: 'No one with complete compensation plan to calculate or the period specified is not at the end of the plan element interval'
4891: );

Line 4888: cn_message_pkg.rollback_errormsg_commit

4884: END IF;
4885: EXCEPTION
4886: WHEN no_comm_lines THEN
4887: cn_message_pkg.DEBUG('Exception occurs in cn_proc_batches_pkg.populate_bonus_process_batch:');
4888: cn_message_pkg.rollback_errormsg_commit
4889: (
4890: 'No one with complete compensation plan to calculate or the period specified is not at the end of the plan element interval'
4891: );
4892: fnd_file.put_line

Line 4908: cn_message_pkg.DEBUG('Exception occurs in cn_proc_batches_pkg.populate_bonus_process_batch: ');

4904: , SQLERRM
4905: );
4906: END IF;
4907:
4908: cn_message_pkg.DEBUG('Exception occurs in cn_proc_batches_pkg.populate_bonus_process_batch: ');
4909: cn_message_pkg.rollback_errormsg_commit(SQLERRM);
4910: fnd_file.put_line(fnd_file.LOG
4911: , 'Exception in cn_proc_batches_pkg.populate_bonus_process_batch: ' || SQLERRM);
4912: RAISE;

Line 4909: cn_message_pkg.rollback_errormsg_commit(SQLERRM);

4905: );
4906: END IF;
4907:
4908: cn_message_pkg.DEBUG('Exception occurs in cn_proc_batches_pkg.populate_bonus_process_batch: ');
4909: cn_message_pkg.rollback_errormsg_commit(SQLERRM);
4910: fnd_file.put_line(fnd_file.LOG
4911: , 'Exception in cn_proc_batches_pkg.populate_bonus_process_batch: ' || SQLERRM);
4912: RAISE;
4913: END populate_bonus_process_batch;