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.FII_BUDGET_FORECAST_C dependencies on FII_UTIL

Line 170: fii_util.put_line ('Phase: ' || g_phase ||

166:
167: FII_MESSAGE.Func_Fail
168: (func_name =>'FII_BUDGET_FORECAST_C.Purge_All');
169:
170: fii_util.put_line ('Phase: ' || g_phase ||
171: 'Error: ' || sqlerrm);
172:
173: RETURN FALSE;
174:

Line 190: fii_util.put_line ('Phase: ' || g_phase ||

186:
187: FII_MESSAGE.Func_Fail
188: (func_name => 'FII_BUDGET_FORECAST_C.Purge_All');
189:
190: fii_util.put_line ('Phase: ' || g_phase ||
191: 'Error: ' || sqlerrm);
192:
193: RETURN FALSE;
194:

Line 474: fii_util.put_line ('Phase: ' || g_phase ||

470:
471: FII_MESSAGE.Func_Fail
472: (func_name =>'FII_BUDGET_FORECAST_C.Purge_Partial');
473:
474: fii_util.put_line ('Phase: ' || g_phase ||
475: 'Error: ' || sqlerrm);
476:
477: RETURN FALSE;
478:

Line 494: fii_util.put_line ('Phase: ' || g_phase ||

490:
491: FII_MESSAGE.Func_Fail
492: (func_name => 'FII_BUDGET_FORECAST_C.Purge_Partial');
493:
494: fii_util.put_line ('Phase: ' || g_phase ||
495: 'Error: ' || sqlerrm);
496:
497: RETURN FALSE;
498:

Line 697: fii_util.put_line ('Phase: ' || g_phase ||

693:
694: FII_MESSAGE.Func_Fail
695: (func_name =>'FII_BUDGET_FORECAST_C.Purge_Eff_Date');
696:
697: fii_util.put_line ('Phase: ' || g_phase ||
698: 'Error: ' || sqlerrm);
699:
700: RETURN FALSE;
701:

Line 717: fii_util.put_line ('Phase: ' || g_phase ||

713:
714: FII_MESSAGE.Func_Fail
715: (func_name => 'FII_BUDGET_FORECAST_C.Purge_Eff_Date');
716:
717: fii_util.put_line ('Phase: ' || g_phase ||
718: 'Error: ' || sqlerrm);
719:
720: RETURN FALSE;
721:

Line 752: FII_UTIL.truncate_table ('FII_BUDGET_STG', 'FII', g_retcode);

748: END IF;
749:
750: -- PSI Budget Extraction will always extract budget data from scratch
751: g_phase := 'Truncate the staging table FII_BUDGET_BASE';
752: FII_UTIL.truncate_table ('FII_BUDGET_STG', 'FII', g_retcode);
753:
754: -- Check if UDD1 is enabled or not
755: SELECT DBI_ENABLED_FLAG
756: INTO l_udd1_enabled_flag

Line 906: fii_util.put_line('l_sqlstmt = '|| l_sqlstmt);

902: ' line.code_combination_id, line.ledger_id, b2.plan_type_code ';
903:
904: -- Print out the dynamic SQL statements if running in debug mode
905: IF (FIIBUUP_DEBUG) THEN
906: fii_util.put_line('l_sqlstmt = '|| l_sqlstmt);
907:
908: FII_MESSAGE.Write_Log
909: (msg_name => 'FII_ROUTINE_VAL',
910: token_num => 3 ,

Line 935: fii_util.put_line('Inserted '||SQL%ROWCOUNT||

931: FIIBUUP_UNASSIGNED_UDD_ID;
932: END IF;
933:
934: IF (FIIBUUP_DEBUG) THEN
935: fii_util.put_line('Inserted '||SQL%ROWCOUNT||
936: ' rows into fii_budget_stg');
937: END IF;
938:
939: -- Need to commit after inserting data into base in parallel mode

Line 972: fii_util.put_line ('Phase: ' || g_phase ||

968:
969: FII_MESSAGE.Func_Fail
970: (func_name =>'FII_BUDGET_FORECAST_C.Psi_Insert_Stg');
971:
972: fii_util.put_line ('Phase: ' || g_phase ||
973: 'Error: ' || sqlerrm);
974: RETURN FALSE;
975:
976: WHEN OTHERS THEN

Line 990: fii_util.put_line ('Phase: ' || g_phase ||

986:
987: FII_MESSAGE.Func_Fail
988: (func_name => 'FII_BUDGET_FORECAST_C.Psi_Insert_Stg');
989:
990: fii_util.put_line ('Phase: ' || g_phase ||
991: 'Error: ' || sqlerrm);
992: RETURN FALSE;
993:
994: END Psi_Insert_Stg;

Line 1124: fii_util.put_line('l_sqlstmt = '|| l_sqlstmt);

1120: ' slba.base_budget_version_id, b.code_combination_id ';
1121:
1122: -- Print out the dynamic SQL statements if running in debug mode
1123: IF (FIIBUUP_DEBUG) THEN
1124: fii_util.put_line('l_sqlstmt = '|| l_sqlstmt);
1125:
1126: FII_MESSAGE.Write_Log
1127: (msg_name => 'FII_ROUTINE_VAL',
1128: token_num => 3 ,

Line 1153: fii_util.put_line('Inserted '||SQL%ROWCOUNT||

1149: FIIBUUP_UNASSIGNED_UDD_ID;
1150: END IF;
1151:
1152: IF (FIIBUUP_DEBUG) THEN
1153: fii_util.put_line('Inserted '||SQL%ROWCOUNT||
1154: ' rows into fii_budget_stg');
1155: END IF;
1156:
1157: -- Need to commit after inserting data into base in parallel mode

Line 1190: fii_util.put_line ('Phase: ' || g_phase ||

1186:
1187: FII_MESSAGE.Func_Fail
1188: (func_name =>'FII_BUDGET_FORECAST_C.Psi_Carry_Forward');
1189:
1190: fii_util.put_line ('Phase: ' || g_phase ||
1191: 'Error: ' || sqlerrm);
1192: RETURN FALSE;
1193:
1194: WHEN OTHERS THEN

Line 1208: fii_util.put_line ('Phase: ' || g_phase ||

1204:
1205: FII_MESSAGE.Func_Fail
1206: (func_name => 'FII_BUDGET_FORECAST_C.Psi_Carry_Forward');
1207:
1208: fii_util.put_line ('Phase: ' || g_phase ||
1209: 'Error: ' || sqlerrm);
1210: RETURN FALSE;
1211:
1212: END Psi_Carry_Forward;

Line 1281: fii_util.put_line('l_sqlstmt = '|| l_sqlstmt);

1277: ' WHERE ent_year_id IS NOT NULL ';
1278:
1279: -- Print out the dynamic SQL statements if running in debug mode
1280: IF (FIIBUUP_DEBUG) THEN
1281: fii_util.put_line('l_sqlstmt = '|| l_sqlstmt);
1282:
1283: FII_MESSAGE.Write_Log
1284: (msg_name => 'FII_ROUTINE_VAL',
1285: token_num => 3 ,

Line 1298: fii_util.put_line('Inserted '||SQL%ROWCOUNT||

1294: -- Execute statement
1295: EXECUTE IMMEDIATE l_sqlstmt;
1296:
1297: IF (FIIBUUP_DEBUG) THEN
1298: fii_util.put_line('Inserted '||SQL%ROWCOUNT||
1299: ' rows into fii_budget_stg');
1300: END IF;
1301:
1302: -- Need to commit

Line 1335: fii_util.put_line ('Phase: ' || g_phase ||

1331:
1332: FII_MESSAGE.Func_Fail
1333: (func_name =>'FII_BUDGET_FORECAST_C.Psi_Rollup');
1334:
1335: fii_util.put_line ('Phase: ' || g_phase ||
1336: 'Error: ' || sqlerrm);
1337: RETURN FALSE;
1338:
1339: WHEN OTHERS THEN

Line 1353: fii_util.put_line ('Phase: ' || g_phase ||

1349:
1350: FII_MESSAGE.Func_Fail
1351: (func_name => 'FII_BUDGET_FORECAST_C.Psi_Rollup');
1352:
1353: fii_util.put_line ('Phase: ' || g_phase ||
1354: 'Error: ' || sqlerrm);
1355: RETURN FALSE;
1356:
1357: END Psi_Rollup;

Line 1455: fii_util.put_line('l_sqlstmt = '|| l_sqlstmt);

1451: ' posted_date) ';
1452:
1453: -- Print out the dynamic SQL statements if running in debug mode
1454: IF (FIIBUUP_DEBUG) THEN
1455: fii_util.put_line('l_sqlstmt = '|| l_sqlstmt);
1456:
1457: FII_MESSAGE.Write_Log
1458: (msg_name => 'FII_ROUTINE_VAL',
1459: token_num => 3 ,

Line 1472: fii_util.put_line('Deleted '||SQL%ROWCOUNT||

1468: -- Execute statement
1469: EXECUTE IMMEDIATE l_sqlstmt;
1470:
1471: IF (FIIBUUP_DEBUG) THEN
1472: fii_util.put_line('Deleted '||SQL%ROWCOUNT||
1473: ' rows from fii_budget_base');
1474: END IF;
1475:
1476: -- Need to commit

Line 1509: fii_util.put_line ('Phase: ' || g_phase ||

1505:
1506: FII_MESSAGE.Func_Fail
1507: (func_name =>'FII_BUDGET_FORECAST_C.Psi_DeleteDiff');
1508:
1509: fii_util.put_line ('Phase: ' || g_phase ||
1510: 'Error: ' || sqlerrm);
1511: RETURN FALSE;
1512:
1513: WHEN OTHERS THEN

Line 1527: fii_util.put_line ('Phase: ' || g_phase ||

1523:
1524: FII_MESSAGE.Func_Fail
1525: (func_name => 'FII_BUDGET_FORECAST_C.Psi_DeleteDiff');
1526:
1527: fii_util.put_line ('Phase: ' || g_phase ||
1528: 'Error: ' || sqlerrm);
1529: RETURN FALSE;
1530:
1531: END Psi_DeleteDiff;

Line 1628: fii_util.put_line('l_sqlstmt = '|| l_sqlstmt);

1624: ' FROM fii_budget_base ';
1625:
1626: -- Print out the dynamic SQL statements if running in debug mode
1627: IF (FIIBUUP_DEBUG) THEN
1628: fii_util.put_line('l_sqlstmt = '|| l_sqlstmt);
1629:
1630: FII_MESSAGE.Write_Log
1631: (msg_name => 'FII_ROUTINE_VAL',
1632: token_num => 3 ,

Line 1649: fii_util.put_line('Inserted '||SQL%ROWCOUNT||

1645: FIIBUUP_USER_ID, FIIBUUP_USER_ID,
1646: FIIBUUP_LOGIN_ID, FIIBUUP_GLOBAL_START_DATE;
1647:
1648: IF (FIIBUUP_DEBUG) THEN
1649: fii_util.put_line('Inserted '||SQL%ROWCOUNT||
1650: ' rows into fii_budget_base');
1651: END IF;
1652:
1653: -- Need to commit

Line 1686: fii_util.put_line ('Phase: ' || g_phase ||

1682:
1683: FII_MESSAGE.Func_Fail
1684: (func_name =>'FII_BUDGET_FORECAST_C.Psi_Insert_Base');
1685:
1686: fii_util.put_line ('Phase: ' || g_phase ||
1687: 'Error: ' || sqlerrm);
1688: RETURN FALSE;
1689:
1690: WHEN OTHERS THEN

Line 1704: fii_util.put_line ('Phase: ' || g_phase ||

1700:
1701: FII_MESSAGE.Func_Fail
1702: (func_name => 'FII_BUDGET_FORECAST_C.Psi_Insert_Base');
1703:
1704: fii_util.put_line ('Phase: ' || g_phase ||
1705: 'Error: ' || sqlerrm);
1706: RETURN FALSE;
1707:
1708: END Psi_Insert_Base;

Line 1838: FII_UTIL.Write_Output (' ');

1834: IF (NOT l_print_hdr1) THEN
1835: -- Set the return code so the program will ends with warning.
1836: retcode := 'W';
1837:
1838: FII_UTIL.Write_Output (' ');
1839: FII_MESSAGE.Write_Log (msg_name => 'FII_INV_FUNC_CURR_CODE',
1840: token_num => 0);
1841: FII_MESSAGE.Write_Log (msg_name => 'FII_REFER_TO_OUTPUT',
1842: token_num => 0);

Line 1848: FII_UTIL.Write_Output (l_sob_name || ' (' || l_currency_code || ')');

1844: token_num => 0);
1845: l_print_hdr1 := TRUE;
1846: END IF;
1847:
1848: FII_UTIL.Write_Output (l_sob_name || ' (' || l_currency_code || ')');
1849: END LOOP;
1850:
1851: ------------------------------------------------------------------------
1852: -- Insert budget data into FII_BUDGET_STG from gl_je_headers/lines

Line 1877: FII_UTIL.Write_Output (' ');

1873: l_acct := rec_csr.concatenated_segments;
1874: l_budget_name := rec_csr.budget_name;
1875:
1876: IF (NOT l_print_hdr1) THEN
1877: FII_UTIL.Write_Output (' ');
1878: FII_MESSAGE.Write_Log (msg_name => 'FII_CCID_ACROSS_BUDGETS',
1879: token_num => 0);
1880: FII_MESSAGE.Write_Log (msg_name => 'FII_REFER_TO_OUTPUT',
1881: token_num => 0);

Line 1888: FII_UTIL.Write_Output (l_acct|| ' ' || l_budget_name );

1884: token_num => 0);
1885: l_print_hdr1 := TRUE;
1886: END IF;
1887:
1888: FII_UTIL.Write_Output (l_acct|| ' ' || l_budget_name );
1889: END LOOP;
1890:
1891: ------------------------------------------------------------------------
1892: -- Rollup budget data along time dimension

Line 1909: FII_UTIL.Write_Output (' ');

1905: l_sob_name := rec_csr.name;
1906:
1907: IF (NOT l_print_hdr1) THEN
1908: retcode := 'W';
1909: FII_UTIL.Write_Output (' ');
1910: FII_MESSAGE.Write_Log (msg_name => 'FII_PSI_BASELINE_CHANGED',
1911: token_num => 0);
1912: FII_MESSAGE.Write_Log (msg_name => 'FII_REFER_TO_OUTPUT',
1913: token_num => 0);

Line 1919: FII_UTIL.Write_Output (l_sob_name);

1915: token_num => 0);
1916: l_print_hdr1 := TRUE;
1917:
1918: END IF;
1919: FII_UTIL.Write_Output (l_sob_name);
1920: END LOOP;
1921:
1922: ------------------------------------------------------------------------
1923: -- Delete time/dimension combination not exists in new data in fii_budget_stg

Line 1937: fii_util.write_log('Error in FII_GL_EXTRACTION_UTIL.LOAD_CCC_MGR ...');

1933:
1934: FII_GL_EXTRACTION_UTIL.LOAD_CCC_MGR (l_status);
1935:
1936: IF l_status = -1 then
1937: fii_util.write_log('Error in FII_GL_EXTRACTION_UTIL.LOAD_CCC_MGR ...');
1938: fii_util.write_log('Table FII_CCC_MGR_GT is not populated');
1939: raise NO_DATA_FOUND;
1940: END IF;
1941:

Line 1938: fii_util.write_log('Table FII_CCC_MGR_GT is not populated');

1934: FII_GL_EXTRACTION_UTIL.LOAD_CCC_MGR (l_status);
1935:
1936: IF l_status = -1 then
1937: fii_util.write_log('Error in FII_GL_EXTRACTION_UTIL.LOAD_CCC_MGR ...');
1938: fii_util.write_log('Table FII_CCC_MGR_GT is not populated');
1939: raise NO_DATA_FOUND;
1940: END IF;
1941:
1942: -- Bug 5004852: Populate company_cost_center_org_id in fii_budget_stg

Line 2015: fii_util.put_line ('Phase: ' || g_phase ||

2011:
2012: FII_MESSAGE.Func_Fail
2013: (func_name =>'FII_BUDGET_FORECAST_C.Psi_Budget_Extract');
2014:
2015: fii_util.put_line ('Phase: ' || g_phase ||
2016: 'Error: ' || sqlerrm);
2017:
2018: retcode := 'E';
2019:

Line 2035: fii_util.put_line ('Phase: ' || g_phase ||

2031:
2032: FII_MESSAGE.Func_Fail
2033: (func_name => 'FII_BUDGET_FORECAST_C.Psi_Budget_Extract');
2034:
2035: fii_util.put_line ('Phase: ' || g_phase ||
2036: 'Error: ' || sqlerrm);
2037:
2038: retcode := 'E';
2039:

Line 2188: fii_util.write_log('Error in FII_GL_EXTRACTION_UTIL.LOAD_CCC_MGR ...');

2184: g_phase := 'Call program that populates CCC - Mgr mappings temp table.';
2185: FII_GL_EXTRACTION_UTIL.LOAD_CCC_MGR (l_status);
2186:
2187: IF l_status = -1 then
2188: fii_util.write_log('Error in FII_GL_EXTRACTION_UTIL.LOAD_CCC_MGR ...');
2189: fii_util.write_log('Table FII_CCC_MGR_GT is not populated');
2190: raise NO_DATA_FOUND;
2191: END IF;
2192:

Line 2189: fii_util.write_log('Table FII_CCC_MGR_GT is not populated');

2185: FII_GL_EXTRACTION_UTIL.LOAD_CCC_MGR (l_status);
2186:
2187: IF l_status = -1 then
2188: fii_util.write_log('Error in FII_GL_EXTRACTION_UTIL.LOAD_CCC_MGR ...');
2189: fii_util.write_log('Table FII_CCC_MGR_GT is not populated');
2190: raise NO_DATA_FOUND;
2191: END IF;
2192:
2193: g_phase := 'Value to ID Conversion';

Line 2346: fii_util.put_line ('Phase: ' || g_phase ||

2342:
2343: FII_MESSAGE.Func_Fail
2344: (func_name =>'FII_BUDGET_FORECAST_C.Id_Convert');
2345:
2346: fii_util.put_line ('Phase: ' || g_phase ||
2347: 'Error: ' || sqlerrm);
2348:
2349: RETURN FALSE;
2350:

Line 2366: fii_util.put_line ('Phase: ' || g_phase ||

2362:
2363: FII_MESSAGE.Func_Fail
2364: (func_name => 'FII_BUDGET_FORECAST_C.Id_Convert');
2365:
2366: fii_util.put_line ('Phase: ' || g_phase ||
2367: 'Error: ' || sqlerrm);
2368:
2369: RETURN FALSE;
2370:

Line 2736: FII_UTIL.Write_Log ('Removing last processed records from the interface table');

2732: retcode := 'S';
2733:
2734: --Remove records with non-null status_code from the interface table
2735: IF (FIIBUUP_DEBUG) THEN
2736: FII_UTIL.Write_Log ('Removing last processed records from the interface table');
2737: END IF;
2738:
2739: g_phase := 'Delete from FII_BUDGET_INTERFACE for not-null status_code';
2740: delete from FII_BUDGET_INTERFACE

Line 2745: FII_UTIL.Write_Log ('Updating new records in the interface table');

2741: where status_code is not NULL;
2742:
2743: -- Update records as 'VALIDATED' and set the upload date to sysdate
2744: IF (FIIBUUP_DEBUG) THEN
2745: FII_UTIL.Write_Log ('Updating new records in the interface table');
2746: END IF;
2747:
2748: g_phase := 'Update all other records to status_code = VALIDATED and upload_date = sysdate';
2749: update FII_BUDGET_INTERFACE

Line 2770: FII_UTIL.Write_Output (' ');

2766: FOR rec_csr IN planCursor LOOP
2767: l_plan_code := rec_csr.plan_type_code;
2768: l_prim_amount_g := rec_csr.prim_amount_g;
2769: IF (NOT l_print_hdr1) THEN
2770: FII_UTIL.Write_Output (' ');
2771: FII_MESSAGE.Write_Log (msg_name => 'FII_INV_PLAN_TYPE_CODE',
2772: token_num => 0);
2773: FII_MESSAGE.Write_Log (msg_name => 'FII_REFER_TO_OUTPUT',
2774: token_num => 0);

Line 2784: FII_UTIL.Write_Output (l_plan_code || ' ' || l_prim_amount_g);

2780: token_num => 0);
2781: l_print_hdr1 := TRUE;
2782: END IF;
2783:
2784: FII_UTIL.Write_Output (l_plan_code || ' ' || l_prim_amount_g);
2785:
2786: UPDATE FII_BUDGET_INTERFACE
2787: SET status_code = 'ERROR'
2788: WHERE CURRENT OF planCursor;

Line 2812: FII_UTIL.Write_Output (' ');

2808: For rec_csr IN csr_null_time_1 LOOP
2809: l_plan_code := rec_csr.plan_type_code;
2810: l_prim_amount_g := rec_csr.prim_amount_g;
2811: IF (NOT l_print_hdr1) THEN
2812: FII_UTIL.Write_Output (' ');
2813: FII_MESSAGE.Write_Log (msg_name => 'FII_MISS_TIME_BUD_FRC',
2814: token_num => 0);
2815: FII_MESSAGE.Write_Log (msg_name => 'FII_REFER_TO_OUTPUT',
2816: token_num => 0);

Line 2826: FII_UTIL.Write_Output (l_plan_code || ' ' || l_prim_amount_g);

2822: token_num => 0);
2823: l_print_hdr1 := TRUE;
2824: END IF;
2825:
2826: FII_UTIL.Write_Output (l_plan_code || ' ' || l_prim_amount_g);
2827:
2828: UPDATE FII_BUDGET_INTERFACE
2829: SET Status_Code = 'ERROR'
2830: WHERE CURRENT OF csr_null_time_1;

Line 2839: FII_UTIL.Write_Output (' ');

2835: For rec_csr IN csr_null_time_2 LOOP
2836: l_plan_code := rec_csr.plan_type_code;
2837: l_prim_amount_g := rec_csr.prim_amount_g;
2838: IF (NOT l_print_hdr1) THEN
2839: FII_UTIL.Write_Output (' ');
2840: FII_MESSAGE.Write_Log (msg_name => 'FII_MISS_TIME_BUD',
2841: token_num => 0);
2842: FII_MESSAGE.Write_Log (msg_name => 'FII_REFER_TO_OUTPUT',
2843: token_num => 0);

Line 2853: FII_UTIL.Write_Output (l_plan_code || ' ' || l_prim_amount_g);

2849: token_num => 0);
2850: l_print_hdr1 := TRUE;
2851: END IF;
2852:
2853: FII_UTIL.Write_Output (l_plan_code || ' ' || l_prim_amount_g);
2854:
2855: UPDATE FII_BUDGET_INTERFACE
2856: SET Status_Code = 'ERROR'
2857: WHERE CURRENT OF csr_null_time_2;

Line 2867: FII_UTIL.Write_Output (' ');

2863: For rec_csr IN csr_null_time_3 LOOP
2864: l_plan_code := rec_csr.plan_type_code;
2865: l_prim_amount_g := rec_csr.prim_amount_g;
2866: IF (NOT l_print_hdr1) THEN
2867: FII_UTIL.Write_Output (' ');
2868: FII_MESSAGE.Write_Log (msg_name => 'FII_MISS_TIME_FRC',
2869: token_num => 0);
2870: FII_MESSAGE.Write_Log (msg_name => 'FII_REFER_TO_OUTPUT',
2871: token_num => 0);

Line 2881: FII_UTIL.Write_Output (l_plan_code || ' ' || l_prim_amount_g);

2877: token_num => 0);
2878: l_print_hdr1 := TRUE;
2879: END IF;
2880:
2881: FII_UTIL.Write_Output (l_plan_code || ' ' || l_prim_amount_g);
2882:
2883: UPDATE FII_BUDGET_INTERFACE
2884: SET Status_Code = 'ERROR'
2885: WHERE CURRENT OF csr_null_time_3;

Line 2965: FII_UTIL.Write_Output (' ');

2961:
2962: l_violations_found := TRUE;
2963:
2964: IF (NOT l_print_hdr1) THEN
2965: FII_UTIL.Write_Output (' ');
2966: FII_MESSAGE.Write_Log (msg_name => 'FII_INV_RPT_TIME_BUD',
2967: token_num => 0);
2968: FII_MESSAGE.Write_Log (msg_name => 'FII_REFER_TO_OUTPUT',
2969: token_num => 0);

Line 3056: FII_UTIL.Write_Output (' ');

3052: l_violations_found := TRUE;
3053:
3054: -- Print header information to output file.
3055: IF (NOT l_print_hdr1) THEN
3056: FII_UTIL.Write_Output (' ');
3057: FII_MESSAGE.Write_Log (msg_name => 'FII_INV_RPT_TIME_FRC',
3058: token_num => 0);
3059: FII_MESSAGE.Write_Log (msg_name => 'FII_REFER_TO_OUTPUT',
3060: token_num => 0);

Line 3107: FII_UTIL.Write_Output (' ');

3103: FOR rec_csr IN csr_null_ledger_id LOOP
3104: l_plan_code := rec_csr.plan_type_code;
3105: l_prim_amount_g := rec_csr.prim_amount_g;
3106: IF (NOT l_print_hdr1) THEN
3107: FII_UTIL.Write_Output (' ');
3108: FII_MESSAGE.Write_Log (msg_name => 'FII_MISS_LEDGER_ID_BUD',
3109: token_num => 0);
3110: FII_MESSAGE.Write_Log (msg_name => 'FII_REFER_TO_OUTPUT',
3111: token_num => 0);

Line 3122: FII_UTIL.Write_Output (l_plan_code || ' ' || l_prim_amount_g);

3118: token_num => 0);
3119: l_print_hdr1 := TRUE;
3120: END IF;
3121:
3122: FII_UTIL.Write_Output (l_plan_code || ' ' || l_prim_amount_g);
3123:
3124: UPDATE FII_BUDGET_INTERFACE
3125: SET status_code = 'ERROR'
3126: WHERE CURRENT OF csr_null_ledger_id;

Line 3149: FII_UTIL.Write_Output (' ');

3145: FOR rec_csr IN csr_null_com_id LOOP
3146: l_plan_code := rec_csr.plan_type_code;
3147: l_prim_amount_g := rec_csr.prim_amount_g;
3148: IF (NOT l_print_hdr1) THEN
3149: FII_UTIL.Write_Output (' ');
3150: FII_MESSAGE.Write_Log (msg_name => 'FII_MISS_CO_ID_BUD',
3151: token_num => 0);
3152: FII_MESSAGE.Write_Log (msg_name => 'FII_REFER_TO_OUTPUT',
3153: token_num => 0);

Line 3164: FII_UTIL.Write_Output (l_plan_code || ' ' || l_prim_amount_g);

3160: token_num => 0);
3161: l_print_hdr1 := TRUE;
3162: END IF;
3163:
3164: FII_UTIL.Write_Output (l_plan_code || ' ' || l_prim_amount_g);
3165:
3166: UPDATE FII_BUDGET_INTERFACE
3167: SET status_code = 'ERROR'
3168: WHERE CURRENT OF csr_null_com_id;

Line 3191: FII_UTIL.Write_Output (' ');

3187: FOR rec_csr IN csr_null_cc_id LOOP
3188: l_plan_code := rec_csr.plan_type_code;
3189: l_prim_amount_g := rec_csr.prim_amount_g;
3190: IF (NOT l_print_hdr1) THEN
3191: FII_UTIL.Write_Output (' ');
3192: FII_MESSAGE.Write_Log (msg_name => 'FII_MISS_CC_ID_BUD',
3193: token_num => 0);
3194: FII_MESSAGE.Write_Log (msg_name => 'FII_REFER_TO_OUTPUT',
3195: token_num => 0);

Line 3206: FII_UTIL.Write_Output (l_plan_code || ' ' || l_prim_amount_g);

3202: token_num => 0);
3203: l_print_hdr1 := TRUE;
3204: END IF;
3205:
3206: FII_UTIL.Write_Output (l_plan_code || ' ' || l_prim_amount_g);
3207:
3208: UPDATE FII_BUDGET_INTERFACE
3209: SET status_code = 'ERROR'
3210: WHERE CURRENT OF csr_null_cc_id;

Line 3235: FII_UTIL.Write_Output (' ');

3231: FOR rec_csr IN csr_null_fin_cat_id LOOP
3232: l_plan_code := rec_csr.plan_type_code;
3233: l_prim_amount_g := rec_csr.prim_amount_g;
3234: IF (NOT l_print_hdr1) THEN
3235: FII_UTIL.Write_Output (' ');
3236: FII_MESSAGE.Write_Log (msg_name => 'FII_MISS_FIN_CAT_ID_BUD',
3237: token_num => 0);
3238: FII_MESSAGE.Write_Log (msg_name => 'FII_REFER_TO_OUTPUT',
3239: token_num => 0);

Line 3250: FII_UTIL.Write_Output (l_plan_code || ' ' || l_prim_amount_g);

3246: token_num => 0);
3247: l_print_hdr1 := TRUE;
3248: END IF;
3249:
3250: FII_UTIL.Write_Output (l_plan_code || ' ' || l_prim_amount_g);
3251:
3252: UPDATE FII_BUDGET_INTERFACE
3253: SET Status_Code = 'ERROR'
3254: WHERE CURRENT OF csr_null_fin_cat_id;

Line 3309: FII_UTIL.Write_Output (' ');

3305: l_violations_found := TRUE;
3306:
3307: -- print header information into output file
3308: IF (NOT l_print_hdr1) THEN
3309: FII_UTIL.Write_Output (' ');
3310: FII_MESSAGE.Write_Log (msg_name => 'FII_INV_LEDGER_ID_DATA',
3311: token_num => 0);
3312: FII_MESSAGE.Write_Log (msg_name => 'FII_REFER_TO_OUTPUT',
3313: token_num => 0);

Line 3322: FII_UTIL.Write_Output (l_ledger_id || ' ' || l_ledger);

3318: l_print_hdr1 := TRUE;
3319: END IF;
3320:
3321: -- print out individual invalid ledger id
3322: FII_UTIL.Write_Output (l_ledger_id || ' ' || l_ledger);
3323:
3324: UPDATE FII_BUDGET_INTERFACE
3325: SET status_code = 'ERROR'
3326: WHERE CURRENT OF ledgerCursor;

Line 3353: FII_UTIL.Write_Output (' ');

3349: l_violations_found := TRUE;
3350:
3351: -- print header information into output file
3352: IF (NOT l_print_hdr1) THEN
3353: FII_UTIL.Write_Output (' ');
3354: FII_MESSAGE.Write_Log (msg_name => 'FII_INV_CO_ID_DATA',
3355: token_num => 0);
3356: FII_MESSAGE.Write_Log (msg_name => 'FII_REFER_TO_OUTPUT',
3357: token_num => 0);

Line 3366: FII_UTIL.Write_Output (l_com_id || ' ' || l_com);

3362: l_print_hdr1 := TRUE;
3363: END IF;
3364:
3365: -- print out individual invalid company id
3366: FII_UTIL.Write_Output (l_com_id || ' ' || l_com);
3367:
3368: UPDATE FII_BUDGET_INTERFACE
3369: SET status_code = 'ERROR'
3370: WHERE CURRENT OF comCursor;

Line 3397: FII_UTIL.Write_Output (' ');

3393: l_violations_found := TRUE;
3394:
3395: -- print header information into output file
3396: IF (NOT l_print_hdr1) THEN
3397: FII_UTIL.Write_Output (' ');
3398: FII_MESSAGE.Write_Log (msg_name => 'FII_INV_CC_ID_DATA',
3399: token_num => 0);
3400: FII_MESSAGE.Write_Log (msg_name => 'FII_REFER_TO_OUTPUT',
3401: token_num => 0);

Line 3410: FII_UTIL.Write_Output (l_cc_id || ' ' || l_cc);

3406: l_print_hdr1 := TRUE;
3407: END IF;
3408:
3409: -- print out individual invalid cost center id
3410: FII_UTIL.Write_Output (l_cc_id || ' ' || l_cc);
3411:
3412: UPDATE FII_BUDGET_INTERFACE
3413: SET status_code = 'ERROR'
3414: WHERE CURRENT OF ccCursor;

Line 3440: FII_UTIL.Write_Output (' ');

3436: l_violations_found := TRUE;
3437:
3438: -- print header information into output file
3439: IF (NOT l_print_hdr1) THEN
3440: FII_UTIL.Write_Output (' ');
3441: FII_MESSAGE.Write_Log (msg_name => 'FII_INV_FIN_CAT_ID_DATA',
3442: token_num => 0);
3443: FII_MESSAGE.Write_Log (msg_name => 'FII_REFER_TO_OUTPUT',
3444: token_num => 0);

Line 3453: FII_UTIL.Write_Output (l_fin_cat_id || ' ' || l_fin_item);

3449: l_print_hdr1 := TRUE;
3450: END IF;
3451:
3452: -- print out individual invalid financial category id
3453: FII_UTIL.Write_Output (l_fin_cat_id || ' ' || l_fin_item);
3454:
3455: UPDATE FII_BUDGET_INTERFACE
3456: SET status_code = 'ERROR'
3457: WHERE CURRENT OF fincatCursor;

Line 3487: FII_UTIL.Write_Output (' ');

3483: l_violations_found := TRUE;
3484:
3485: -- print header information into output file
3486: IF (NOT l_print_hdr1) THEN
3487: FII_UTIL.Write_Output (' ');
3488: FII_MESSAGE.Write_Log (msg_name => 'FII_INV_PROD_CAT_ID_DATA',
3489: token_num => 0);
3490: FII_MESSAGE.Write_Log (msg_name => 'FII_REFER_TO_OUTPUT',
3491: token_num => 0);

Line 3500: FII_UTIL.Write_Output (l_prod_cat_id || ' ' || l_prod_code);

3496: l_print_hdr1 := TRUE;
3497: END IF;
3498:
3499: -- print out individual invalid product category id
3500: FII_UTIL.Write_Output (l_prod_cat_id || ' ' || l_prod_code);
3501:
3502: UPDATE FII_BUDGET_INTERFACE
3503: SET Status_Code = 'ERROR'
3504: WHERE CURRENT OF prodCursor;

Line 3534: FII_UTIL.Write_Output (' ');

3530: l_violations_found := TRUE;
3531:
3532: -- print header information into output file
3533: IF (NOT l_print_hdr1) THEN
3534: FII_UTIL.Write_Output (' ');
3535: FII_MESSAGE.Write_Log (msg_name => 'FII_INV_UDD1_ID_DATA',
3536: token_num => 0);
3537: FII_MESSAGE.Write_Log (msg_name => 'FII_REFER_TO_OUTPUT',
3538: token_num => 0);

Line 3547: FII_UTIL.Write_Output (l_udd1_id || ' ' || l_udd1);

3543: l_print_hdr1 := TRUE;
3544: END IF;
3545:
3546: -- print out individual invalid user defined dimension 1 ID
3547: FII_UTIL.Write_Output (l_udd1_id || ' ' || l_udd1);
3548:
3549: UPDATE FII_BUDGET_INTERFACE
3550: SET status_code = 'ERROR'
3551: WHERE CURRENT OF udd1Cursor;

Line 3580: FII_UTIL.Write_Output (' ');

3576: For rec_csr IN rateCursor LOOP
3577: l_plan_code := rec_csr.plan_type_code;
3578: l_prim_amount_g := rec_csr.prim_amount_g;
3579: IF (NOT l_print_hdr1) THEN
3580: FII_UTIL.Write_Output (' ');
3581: FII_MESSAGE.Write_Log (msg_name => 'FII_CUR_GLB_PRM',
3582: token_num => 0);
3583: FII_MESSAGE.Write_Log (msg_name => 'FII_REFER_TO_OUTPUT',
3584: token_num => 0);

Line 3594: FII_UTIL.Write_Output (l_plan_code || ' ' || l_prim_amount_g);

3590: token_num => 0);
3591: l_print_hdr1 := TRUE;
3592: END IF;
3593:
3594: FII_UTIL.Write_Output (l_plan_code || ' ' || l_prim_amount_g);
3595:
3596: UPDATE FII_BUDGET_INTERFACE
3597: SET Status_Code = 'ERROR'
3598: WHERE CURRENT OF rateCursor;

Line 3631: FII_UTIL.Write_Output (' ');

3627: l_violations_found := TRUE;
3628:
3629: -- Print header information to output file.
3630: IF (l_plan_code = 'B' AND (NOT l_print_hdr1)) THEN
3631: FII_UTIL.Write_Output (' ');
3632: FII_MESSAGE.Write_Log (msg_name => 'FII_BUD_MLTP_REC',
3633: token_num => 0);
3634: FII_MESSAGE.Write_Log (msg_name => 'FII_REFER_TO_OUTPUT',
3635: token_num => 0);

Line 3653: FII_UTIL.Write_Output (l_ver_date || ' ' ||

3649: l_print_hdr2 := TRUE;
3650: END IF;
3651:
3652: -- Print out individual duplicate record
3653: FII_UTIL.Write_Output (l_ver_date || ' ' ||
3654: l_time_unit || ' ' ||
3655: l_ledger_id || ' ' ||
3656: l_com_id || ' ' ||
3657: l_cc_id || ' ' ||

Line 3705: FII_UTIL.Write_Output (' ');

3701: l_violations_found := TRUE;
3702:
3703: -- Print header information to output file.
3704: IF (l_plan_code = 'B' AND (NOT l_print_hdr1)) THEN
3705: FII_UTIL.Write_Output (' ');
3706: FII_MESSAGE.Write_Log (msg_name => 'FII_BUD_INV_VER_DATE',
3707: token_num => 0);
3708: FII_MESSAGE.Write_Log (msg_name => 'FII_REFER_TO_OUTPUT',
3709: token_num => 0);

Line 3727: FII_UTIL.Write_Output (l_ver_date || ' ' ||

3723: l_print_hdr2 := TRUE;
3724: END IF;
3725:
3726: -- Print out individual record with invalid version date
3727: FII_UTIL.Write_Output (l_ver_date || ' ' ||
3728: l_time_unit || ' ' ||
3729: l_ledger_id || ' ' ||
3730: l_com_id || ' ' ||
3731: l_cc_id || ' ' ||

Line 3764: FII_UTIL.Write_Output (' ');

3760: l_violations_found := TRUE;
3761:
3762: -- Print header information to output file.
3763: IF (l_plan_code = 'B' AND (NOT l_print_hdr1)) THEN
3764: FII_UTIL.Write_Output (' ');
3765: FII_MESSAGE.Write_Log (msg_name => 'FII_BUD_INV_VER_DATE',
3766: token_num => 0);
3767: FII_MESSAGE.Write_Log (msg_name => 'FII_REFER_TO_OUTPUT',
3768: token_num => 0);

Line 3786: FII_UTIL.Write_Output (l_ver_date || ' ' ||

3782: l_print_hdr2 := TRUE;
3783: END IF;
3784:
3785: -- Print out individual record with invalid version date
3786: FII_UTIL.Write_Output (l_ver_date || ' ' ||
3787: l_time_unit || ' ' ||
3788: l_ledger_id || ' ' ||
3789: l_com_id || ' ' ||
3790: l_cc_id || ' ' ||

Line 3823: FII_UTIL.Write_Output (' ');

3819: l_violations_found := TRUE;
3820:
3821: -- Print header information to output file.
3822: IF (l_plan_code = 'B' AND (NOT l_print_hdr1)) THEN
3823: FII_UTIL.Write_Output (' ');
3824: FII_MESSAGE.Write_Log (msg_name => 'FII_BUD_INV_VER_DATE',
3825: token_num => 0);
3826: FII_MESSAGE.Write_Log (msg_name => 'FII_REFER_TO_OUTPUT',
3827: token_num => 0);

Line 3845: FII_UTIL.Write_Output (l_ver_date || ' ' ||

3841: l_print_hdr2 := TRUE;
3842: END IF;
3843:
3844: -- Print out individual record with invalid version date
3845: FII_UTIL.Write_Output (l_ver_date || ' ' ||
3846: l_time_unit || ' ' ||
3847: l_ledger_id || ' ' ||
3848: l_com_id || ' ' ||
3849: l_cc_id || ' ' ||

Line 3887: FII_UTIL.Write_Log ('There is invalid data in the interface table...');

3883: l_count := 0;
3884: END;
3885:
3886: IF l_count > 0 THEN
3887: FII_UTIL.Write_Log ('There is invalid data in the interface table...');
3888: FII_MESSAGE.Func_Succ('FII_BUDGET_FORECAST_C.Validate');
3889: retcode := 'E';
3890: RETURN;
3891: END IF;

Line 3923: fii_util.put_line ('Phase: ' || g_phase ||

3919:
3920: FII_MESSAGE.Func_Fail
3921: (func_name =>'FII_BUDGET_FORECAST_C.Validate');
3922:
3923: fii_util.put_line ('Phase: ' || g_phase ||
3924: 'Error: ' || sqlerrm);
3925: retcode := 'E';
3926: RETURN;
3927:

Line 3942: fii_util.put_line ('Phase: ' || g_phase ||

3938:
3939: FII_MESSAGE.Func_Fail
3940: (func_name => 'FII_BUDGET_FORECAST_C.Validate');
3941:
3942: fii_util.put_line ('Phase: ' || g_phase ||
3943: 'Error: ' || sqlerrm);
3944: retcode := 'E';
3945: RETURN;
3946: END Validate;

Line 4342: fii_util.put_line('l_bud_sqlstmt = '|| l_bud_sqlstmt);

4338: l_fc_sqlstmt := l_fc_sqlstmt || l_tmpstmt;
4339:
4340: -- Print out the dynamic SQL statements if running in debug mode
4341: IF (FIIBUUP_DEBUG) THEN
4342: fii_util.put_line('l_bud_sqlstmt = '|| l_bud_sqlstmt);
4343:
4344: FII_MESSAGE.Write_Log
4345: (msg_name => 'FII_ROUTINE_VAL',
4346: token_num => 3 ,

Line 4354: fii_util.put_line('l_fc_sqlstmt = '|| l_fc_sqlstmt);

4350: v2 => 'LENGTH(l_bud_sqlstmt)',
4351: t3 => 'VALUE',
4352: v3 => TO_CHAR(LENGTH(l_bud_sqlstmt)));
4353:
4354: fii_util.put_line('l_fc_sqlstmt = '|| l_fc_sqlstmt);
4355:
4356: FII_MESSAGE.Write_Log
4357: (msg_name => 'FII_ROUTINE_VAL',
4358: token_num => 3 ,

Line 4376: fii_util.put_line('Inserted '||SQL%ROWCOUNT||

4372: FIIBUUP_USER_ID, FIIBUUP_USER_ID, FIIBUUP_LOGIN_ID, version_date,
4373: FIIBUUP_USER_ID, FIIBUUP_USER_ID, FIIBUUP_LOGIN_ID, version_date;
4374:
4375: IF (FIIBUUP_DEBUG) THEN
4376: fii_util.put_line('Inserted '||SQL%ROWCOUNT||
4377: ' budget rows into fii_budget_deltas');
4378: END IF;
4379:
4380: EXECUTE IMMEDIATE l_fc_sqlstmt

Line 4388: fii_util.put_line('Inserted '||SQL%ROWCOUNT||

4384: FIIBUUP_USER_ID, FIIBUUP_USER_ID, FIIBUUP_LOGIN_ID, version_date,
4385: FIIBUUP_USER_ID, FIIBUUP_USER_ID, FIIBUUP_LOGIN_ID, version_date;
4386:
4387: IF (FIIBUUP_DEBUG) THEN
4388: fii_util.put_line('Inserted '||SQL%ROWCOUNT||
4389: ' forecast rows into fii_budget_deltas');
4390: END IF;
4391:
4392: -- Prior_version completed, return with success

Line 4424: fii_util.put_line ('Phase: ' || g_phase ||

4420:
4421: FII_MESSAGE.Func_Fail
4422: (func_name => 'FII_BUDGET_FORECAST_C.Prior_version');
4423:
4424: fii_util.put_line ('Phase: ' || g_phase ||
4425: 'Error: ' || sqlerrm);
4426: RETURN FALSE;
4427:
4428: WHEN OTHERS THEN

Line 4442: fii_util.put_line ('Phase: ' || g_phase ||

4438:
4439: FII_MESSAGE.Func_Fail
4440: (func_name => 'FII_BUDGET_FORECAST_C.Prior_version' || version_date);
4441:
4442: fii_util.put_line ('Phase: ' || g_phase ||
4443: 'Error: ' || sqlerrm);
4444: RETURN FALSE;
4445: END Prior_version;
4446:

Line 4684: fii_util.put_line('l_bud_sqlstmt = '|| l_bud_sqlstmt);

4680:
4681: -- Print out the dynamic SQL statements if running in debug mode
4682: IF (FIIBUUP_DEBUG) THEN
4683:
4684: fii_util.put_line('l_bud_sqlstmt = '|| l_bud_sqlstmt);
4685:
4686: FII_MESSAGE.Write_Log
4687: (msg_name => 'FII_ROUTINE_VAL',
4688: token_num => 3 ,

Line 4696: fii_util.put_line('l_fc_sqlstmt = '|| l_fc_sqlstmt);

4692: v2 => 'LENGTH(l_bud_sqlstmt)',
4693: t3 => 'VALUE',
4694: v3 => TO_CHAR(LENGTH(l_bud_sqlstmt)));
4695:
4696: fii_util.put_line('l_fc_sqlstmt = '|| l_fc_sqlstmt);
4697:
4698: FII_MESSAGE.Write_Log
4699: (msg_name => 'FII_ROUTINE_VAL',
4700: token_num => 3 ,

Line 4715: fii_util.put_line('Inserted '||SQL%ROWCOUNT||

4711: USING FIIBUUP_USER_ID, FIIBUUP_USER_ID, FIIBUUP_LOGIN_ID,
4712: FIIBUUP_USER_ID, FIIBUUP_USER_ID, FIIBUUP_LOGIN_ID;
4713:
4714: IF (FIIBUUP_DEBUG) THEN
4715: fii_util.put_line('Inserted '||SQL%ROWCOUNT||
4716: ' budget rows into fii_budget_deltas');
4717: END IF;
4718:
4719: EXECUTE IMMEDIATE l_fc_sqlstmt

Line 4724: fii_util.put_line('Inserted '||SQL%ROWCOUNT||

4720: USING FIIBUUP_USER_ID, FIIBUUP_USER_ID, FIIBUUP_LOGIN_ID,
4721: FIIBUUP_USER_ID, FIIBUUP_USER_ID, FIIBUUP_LOGIN_ID;
4722:
4723: IF (FIIBUUP_DEBUG) THEN
4724: fii_util.put_line('Inserted '||SQL%ROWCOUNT||
4725: ' forecast rows into fii_budget_deltas');
4726: END IF;
4727:
4728: -- Prior_version completed, return with success

Line 4759: fii_util.put_line ('Phase: ' || g_phase ||

4755:
4756: FII_MESSAGE.Func_Fail
4757: (func_name => 'FII_BUDGET_FORECAST_C.Prior_version');
4758:
4759: fii_util.put_line ('Phase: ' || g_phase ||
4760: 'Error: ' || sqlerrm);
4761: RETURN FALSE;
4762:
4763: WHEN OTHERS THEN

Line 4777: fii_util.put_line ('Phase: ' || g_phase ||

4773:
4774: FII_MESSAGE.Func_Fail
4775: (func_name => 'FII_BUDGET_FORECAST_C.Prior_version');
4776:
4777: fii_util.put_line ('Phase: ' || g_phase ||
4778: 'Error: ' || sqlerrm);
4779: RETURN FALSE;
4780: END Prior_version;
4781:

Line 5009: fii_util.put_line('l_bud_sqlstmt = '|| l_bud_sqlstmt);

5005: l_fc_sqlstmt := l_fc_sqlstmt || l_tmpstmt;
5006:
5007: -- Print out the dynamic SQL statements if running in debug mode
5008: IF (FIIBUUP_DEBUG) THEN
5009: fii_util.put_line('l_bud_sqlstmt = '|| l_bud_sqlstmt);
5010:
5011: FII_MESSAGE.Write_Log
5012: (msg_name => 'FII_ROUTINE_VAL',
5013: token_num => 3 ,

Line 5021: fii_util.put_line('l_fc_sqlstmt = '|| l_fc_sqlstmt);

5017: v2 => 'LENGTH(l_bud_sqlstmt)',
5018: t3 => 'VALUE',
5019: v3 => TO_CHAR(LENGTH(l_bud_sqlstmt)));
5020:
5021: fii_util.put_line('l_fc_sqlstmt = '|| l_fc_sqlstmt);
5022:
5023: FII_MESSAGE.Write_Log
5024: (msg_name => 'FII_ROUTINE_VAL',
5025: token_num => 3 ,

Line 5153: fii_util.put_line ('Phase: ' || g_phase ||

5149:
5150: FII_MESSAGE.Func_Fail
5151: (func_name => 'FII_BUDGET_FORECAST_C.stage');
5152:
5153: fii_util.put_line ('Phase: ' || g_phase ||
5154: 'Error: ' || sqlerrm);
5155: RETURN FALSE;
5156:
5157: WHEN OTHERS THEN

Line 5171: fii_util.put_line ('Phase: ' || g_phase ||

5167:
5168: FII_MESSAGE.Func_Fail
5169: (func_name => 'FII_BUDGET_FORECAST_C.stage');
5170:
5171: fii_util.put_line ('Phase: ' || g_phase ||
5172: 'Error: ' || sqlerrm);
5173: RETURN FALSE;
5174: END Stage;
5175:

Line 5304: fii_util.put_line('l_bud_sqlstmt = '|| l_bud_sqlstmt);

5300: ' AND s.plan_type_code = ''F'' ';
5301:
5302: -- Print out the dynamic SQL statements if running in debug mode
5303: IF (FIIBUUP_DEBUG) THEN
5304: fii_util.put_line('l_bud_sqlstmt = '|| l_bud_sqlstmt);
5305:
5306: FII_MESSAGE.Write_Log
5307: (msg_name => 'FII_ROUTINE_VAL',
5308: token_num => 3 ,

Line 5316: fii_util.put_line('l_fc_sqlstmt = '|| l_fc_sqlstmt);

5312: v2 => 'LENGTH(l_bud_sqlstmt)',
5313: t3 => 'VALUE',
5314: v3 => TO_CHAR(LENGTH(l_bud_sqlstmt)));
5315:
5316: fii_util.put_line('l_fc_sqlstmt = '|| l_fc_sqlstmt);
5317:
5318: FII_MESSAGE.Write_Log
5319: (msg_name => 'FII_ROUTINE_VAL',
5320: token_num => 3 ,

Line 5454: fii_util.put_line('l_bud_sqlstmt = '|| l_bud_sqlstmt);

5450: END IF;
5451:
5452: -- Print out the dynamic SQL statements if running in debug mode
5453: IF (FIIBUUP_DEBUG) THEN
5454: fii_util.put_line('l_bud_sqlstmt = '|| l_bud_sqlstmt);
5455:
5456: FII_MESSAGE.Write_Log
5457: (msg_name => 'FII_ROUTINE_VAL',
5458: token_num => 3 ,

Line 5466: fii_util.put_line('l_fc_sqlstmt = '|| l_fc_sqlstmt);

5462: v2 => 'LENGTH(l_bud_sqlstmt)',
5463: t3 => 'VALUE',
5464: v3 => TO_CHAR(LENGTH(l_bud_sqlstmt)));
5465:
5466: fii_util.put_line('l_fc_sqlstmt = '|| l_fc_sqlstmt);
5467:
5468: FII_MESSAGE.Write_Log
5469: (msg_name => 'FII_ROUTINE_VAL',
5470: token_num => 3 ,

Line 5566: fii_util.put_line ('Phase: ' || g_phase ||

5562:
5563: FII_MESSAGE.Func_Fail
5564: (func_name => 'FII_BUDGET_FORECAST_C.adjsut_stage');
5565:
5566: fii_util.put_line ('Phase: ' || g_phase ||
5567: 'Error: ' || sqlerrm);
5568: RETURN FALSE;
5569:
5570: WHEN OTHERS THEN

Line 5584: fii_util.put_line ('Phase: ' || g_phase ||

5580:
5581: FII_MESSAGE.Func_Fail
5582: (func_name => 'FII_BUDGET_FORECAST_C.adjust_amount');
5583:
5584: fii_util.put_line ('Phase: ' || g_phase ||
5585: 'Error: ' || sqlerrm);
5586: RETURN FALSE;
5587:
5588: END Adjust_Amount;

Line 5743: fii_util.put_line('l_bud_sqlstmt = '|| l_bud_sqlstmt);

5739: END IF;
5740:
5741: -- Print out the dynamic SQL statements if running in debug mode
5742: IF (FIIBUUP_DEBUG) THEN
5743: fii_util.put_line('l_bud_sqlstmt = '|| l_bud_sqlstmt);
5744:
5745: FII_MESSAGE.Write_Log
5746: (msg_name => 'FII_ROUTINE_VAL',
5747: token_num => 3 ,

Line 5755: fii_util.put_line('l_fc_sqlstmt = '|| l_fc_sqlstmt);

5751: v2 => 'LENGTH(l_bud_sqlstmt)',
5752: t3 => 'VALUE',
5753: v3 => TO_CHAR(LENGTH(l_bud_sqlstmt)));
5754:
5755: fii_util.put_line('l_fc_sqlstmt = '|| l_fc_sqlstmt);
5756:
5757: FII_MESSAGE.Write_Log
5758: (msg_name => 'FII_ROUTINE_VAL',
5759: token_num => 3 ,

Line 5864: fii_util.put_line ('Phase: ' || g_phase ||

5860:
5861: FII_MESSAGE.Func_Fail
5862: (func_name => 'FII_BUDGET_FORECAST_C.rollup_stage');
5863:
5864: fii_util.put_line ('Phase: ' || g_phase ||
5865: 'Error: ' || sqlerrm);
5866: RETURN FALSE;
5867:
5868: WHEN OTHERS THEN

Line 5882: fii_util.put_line ('Phase: ' || g_phase ||

5878:
5879: FII_MESSAGE.Func_Fail
5880: (func_name => 'FII_BUDGET_FORECAST_C.rollup_stage');
5881:
5882: fii_util.put_line ('Phase: ' || g_phase ||
5883: 'Error: ' || sqlerrm);
5884: RETURN FALSE;
5885:
5886: END Rollup_Stage;

Line 5959: fii_util.put_line('l_bud_sqlstmt = '|| l_bud_sqlstmt);

5955: END IF;
5956:
5957: -- Print out the dynamic SQL statements if running in debug mode
5958: IF (FIIBUUP_DEBUG) THEN
5959: fii_util.put_line('l_bud_sqlstmt = '|| l_bud_sqlstmt);
5960:
5961: FII_MESSAGE.Write_Log
5962: (msg_name => 'FII_ROUTINE_VAL',
5963: token_num => 3 ,

Line 5971: fii_util.put_line('l_fc_sqlstmt = '|| l_fc_sqlstmt);

5967: v2 => 'LENGTH(l_bud_sqlstmt)',
5968: t3 => 'VALUE',
5969: v3 => TO_CHAR(LENGTH(l_bud_sqlstmt)));
5970:
5971: fii_util.put_line('l_fc_sqlstmt = '|| l_fc_sqlstmt);
5972:
5973: FII_MESSAGE.Write_Log
5974: (msg_name => 'FII_ROUTINE_VAL',
5975: token_num => 3 ,

Line 6063: fii_util.put_line ('Phase: ' || g_phase ||

6059:
6060: FII_MESSAGE.Func_Fail
6061: (func_name => 'FII_BUDGET_FORECAST_C.adjsut_stage');
6062:
6063: fii_util.put_line ('Phase: ' || g_phase ||
6064: 'Error: ' || sqlerrm);
6065: RETURN FALSE;
6066:
6067: WHEN OTHERS THEN

Line 6081: fii_util.put_line ('Phase: ' || g_phase ||

6077:
6078: FII_MESSAGE.Func_Fail
6079: (func_name => 'FII_BUDGET_FORECAST_C.adjust_stage');
6080:
6081: fii_util.put_line ('Phase: ' || g_phase ||
6082: 'Error: ' || sqlerrm);
6083: RETURN FALSE;
6084:
6085: END Adjust_Stage;

Line 6201: fii_util.put_line('merge stmt = '|| l_tmpstmt );

6197:
6198:
6199: -- Print out the dynamic SQL statements if running in debug mode
6200: IF (FIIBUUP_DEBUG) THEN
6201: fii_util.put_line('merge stmt = '|| l_tmpstmt );
6202:
6203: FII_MESSAGE.Write_Log
6204: (msg_name => 'FII_ROUTINE_VAL',
6205: token_num => 3 ,

Line 6308: fii_util.put_line ('Phase: ' || g_phase ||

6304:
6305: FII_MESSAGE.Func_Fail
6306: (func_name => 'FII_BUDGET_FORECAST_C.merge');
6307:
6308: fii_util.put_line ('Phase: ' || g_phase ||
6309: 'Error: ' || sqlerrm);
6310: RETURN FALSE;
6311:
6312: WHEN OTHERS THEN

Line 6326: fii_util.put_line ('Phase: ' || g_phase ||

6322:
6323: FII_MESSAGE.Func_Fail
6324: (func_name => 'FII_BUDGET_FORECAST_C.merge');
6325:
6326: fii_util.put_line ('Phase: ' || g_phase ||
6327: 'Error: ' || sqlerrm);
6328: RETURN FALSE;
6329:
6330: END Merge;

Line 6400: fii_util.put_line('adjust_ver_date l_bud_sqlstmt = '|| l_bud_sqlstmt);

6396: l_fc_sqlstmt := l_fc_sqlstmt || l_tmpstmt || ' AND b.plan_type_code = ''F'' ';
6397:
6398: -- Print out the dynamic SQL statements if running in debug mode
6399: IF (FIIBUUP_DEBUG) THEN
6400: fii_util.put_line('adjust_ver_date l_bud_sqlstmt = '|| l_bud_sqlstmt);
6401:
6402: FII_MESSAGE.Write_Log
6403: (msg_name => 'FII_ROUTINE_VAL',
6404: token_num => 3 ,

Line 6412: fii_util.put_line('adjust_ver_date l_fc_sqlstmt = '|| l_fc_sqlstmt);

6408: v2 => 'LENGTH(l_bud_sqlstmt)',
6409: t3 => 'VALUE',
6410: v3 => TO_CHAR(LENGTH(l_bud_sqlstmt)));
6411:
6412: fii_util.put_line('adjust_ver_date l_fc_sqlstmt = '|| l_fc_sqlstmt);
6413:
6414: FII_MESSAGE.Write_Log
6415: (msg_name => 'FII_ROUTINE_VAL',
6416: token_num => 3 ,

Line 6492: fii_util.put_line ('Phase: ' || g_phase ||

6488:
6489: FII_MESSAGE.Func_Fail
6490: (func_name => 'FII_BUDGET_FORECAST_C.adjust_ver_date');
6491:
6492: fii_util.put_line ('Phase: ' || g_phase ||
6493: 'Error: ' || sqlerrm);
6494: RETURN FALSE;
6495:
6496: WHEN OTHERS THEN

Line 6510: fii_util.put_line ('Phase: ' || g_phase ||

6506:
6507: FII_MESSAGE.Func_Fail
6508: (func_name => 'FII_BUDGET_FORECAST_C.adjust_ver_date');
6509:
6510: fii_util.put_line ('Phase: ' || g_phase ||
6511: 'Error: ' || sqlerrm);
6512: RETURN FALSE;
6513:
6514: END Adjust_Ver_Date;

Line 7292: FII_UTIL.truncate_table ('FII_BUDGET_DELTAS', 'FII', g_retcode);

7288: v2 => 'Truncating FII_BUDGET_DELTAS...');
7289: END IF;
7290:
7291: g_phase := 'Truncate the staging table FII_BUDGET_DELTAS';
7292: FII_UTIL.truncate_table ('FII_BUDGET_DELTAS', 'FII', g_retcode);
7293:
7294: IF (FIIBUUP_DEBUG) THEN
7295: FII_MESSAGE.Write_Log
7296: (msg_name => 'FII_ROUTINE',

Line 7305: FII_UTIL.truncate_table ('FII_BUDGET_BASE_T', 'FII', g_retcode);

7301: v2 => 'Truncating FII_BUDGET_BASE_T...');
7302: END IF;
7303:
7304: g_phase := 'Truncate the staging table FII_BUDGET_BASE_T';
7305: FII_UTIL.truncate_table ('FII_BUDGET_BASE_T', 'FII', g_retcode);
7306:
7307: IF (FIIBUUP_DEBUG) THEN
7308: FII_MESSAGE.Write_Log
7309: (msg_name => 'FII_ROUTINE',

Line 7318: FII_UTIL.truncate_table ('FII_BUDGET_STG', 'FII', g_retcode);

7314: v2 => 'Truncating FII_BUDGET_STG...');
7315: END IF;
7316:
7317: g_phase := 'Truncate the staging table FII_BUDGET_STG';
7318: FII_UTIL.truncate_table ('FII_BUDGET_STG', 'FII', g_retcode);
7319:
7320: FND_CONCURRENT.Af_Commit;
7321:
7322: -- Check if there is anything to upload. If nothing,

Line 7472: FII_UTIL.truncate_table ('FII_BUDGET_DELTAS', 'FII', g_retcode);

7468: v2 => 'Truncating FII_BUDGET_DELTAS...');
7469: END IF;
7470:
7471: g_phase := 'Truncate the staging table FII_BUDGET_DELTAS';
7472: FII_UTIL.truncate_table ('FII_BUDGET_DELTAS', 'FII', g_retcode);
7473:
7474: IF (FIIBUUP_DEBUG) THEN
7475: FII_MESSAGE.Write_Log
7476: (msg_name => 'FII_ROUTINE',

Line 7485: FII_UTIL.truncate_table ('FII_BUDGET_BASE_T', 'FII', g_retcode);

7481: v2 => 'Truncating FII_BUDGET_BASE_T...');
7482: END IF;
7483:
7484: g_phase := 'Truncate the staging table FII_BUDGET_BASE_T';
7485: FII_UTIL.truncate_table ('FII_BUDGET_BASE_T', 'FII', g_retcode);
7486:
7487: IF (FIIBUUP_DEBUG) THEN
7488: FII_MESSAGE.Write_Log
7489: (msg_name => 'FII_ROUTINE',

Line 7498: FII_UTIL.truncate_table ('FII_BUDGET_STG', 'FII', g_retcode);

7494: v2 => 'Truncating FII_BUDGET_STG...');
7495: END IF;
7496:
7497: g_phase := 'Truncate the staging table FII_BUDGET_STG';
7498: FII_UTIL.truncate_table ('FII_BUDGET_STG', 'FII', g_retcode);
7499:
7500: IF(NOT FII_BUDGET_FORECAST_C.Prior_version(l_version_date)) THEN
7501: raise FIIBUUP_fatal_err;
7502: END IF;

Line 7595: fii_util.put_line ('Phase: ' || g_phase ||

7591: v1 => 'FII_BUDGET_FORECAST_C.Main()');
7592:
7593: FII_MESSAGE.Func_Fail(func_name => 'FII_BUDGET_FORECAST_C.Main');
7594:
7595: fii_util.put_line ('Phase: ' || g_phase ||
7596: 'Error: ' || sqlerrm);
7597:
7598: l_ret_status := FND_CONCURRENT.Set_Completion_Status
7599: (status => 'ERROR', message => substr(sqlerrm,1,180));

Line 7614: fii_util.put_line ('Phase: ' || g_phase ||

7610: v2 => SQLERRM);
7611:
7612: FII_MESSAGE.Func_Fail(func_name => 'FII_BUDGET_FORECAST_C.Main');
7613:
7614: fii_util.put_line ('Phase: ' || g_phase ||
7615: 'Error: ' || sqlerrm);
7616:
7617: l_ret_status := FND_CONCURRENT.Set_Completion_Status
7618: (status => 'ERROR', message => substr(sqlerrm,1,180));