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_BUDGET_FORECAST_C

Line 1: PACKAGE BODY FII_BUDGET_FORECAST_C AS

1: PACKAGE BODY FII_BUDGET_FORECAST_C AS
2: /* $Header: FIIBUUPB.pls 120.59 2007/09/11 09:10:41 wywong ship $ */
3:
4: g_retcode VARCHAR2(20) := NULL;
5: g_phase VARCHAR2(120);

Line 24: -- result := FII_BUDGET_FORECAST_C.Purge_All;

20: -- 06-20-02 S Kung Created
21: -- Arguments
22: -- None
23: -- Example
24: -- result := FII_BUDGET_FORECAST_C.Purge_All;
25: -- Notes
26: --
27: FUNCTION Purge_All RETURN BOOLEAN IS
28: FIIBUUP_fatal_err EXCEPTION;

Line 33: FII_MESSAGE.Func_Ent('FII_BUDGET_FORECAST_C.Purge_All');

29:
30: BEGIN
31:
32: IF (FIIBUUP_DEBUG) THEN
33: FII_MESSAGE.Func_Ent('FII_BUDGET_FORECAST_C.Purge_All');
34: END IF;
35:
36: -- Purge all records from FII_BUDGET_BASE for the specified plan type
37: IF (FIIBUUP_DEBUG) THEN

Line 150: FII_MESSAGE.Func_Succ('FII_BUDGET_FORECAST_C.Purge_All');

146: -- Commit everything to database before returning
147: FND_CONCURRENT.Af_Commit;
148:
149: IF (FIIBUUP_DEBUG) THEN
150: FII_MESSAGE.Func_Succ('FII_BUDGET_FORECAST_C.Purge_All');
151: END IF;
152: RETURN TRUE;
153:
154: -- Exception handling

Line 164: v1 => 'FII_BUDGET_FORECAST_C.Purge_All()');

160: FII_MESSAGE.Write_Log
161: (msg_name => 'FII_ERR_ENC_ROUT',
162: token_num => 1,
163: t1 => 'ROUTINE_NAME',
164: v1 => 'FII_BUDGET_FORECAST_C.Purge_All()');
165:
166:
167: FII_MESSAGE.Func_Fail
168: (func_name =>'FII_BUDGET_FORECAST_C.Purge_All');

Line 168: (func_name =>'FII_BUDGET_FORECAST_C.Purge_All');

164: v1 => 'FII_BUDGET_FORECAST_C.Purge_All()');
165:
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:

Line 183: v1 => 'FII_BUDGET_FORECAST_C.Purge_All()',

179: FII_MESSAGE.Write_Log
180: (msg_name => 'FII_ERROR',
181: token_num => 2,
182: t1 => 'FUNCTION',
183: v1 => 'FII_BUDGET_FORECAST_C.Purge_All()',
184: t2 => 'SQLERRMC',
185: v2 => SQLERRM);
186:
187: FII_MESSAGE.Func_Fail

Line 188: (func_name => 'FII_BUDGET_FORECAST_C.Purge_All');

184: t2 => 'SQLERRMC',
185: v2 => SQLERRM);
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:

Line 209: -- result := FII_BUDGET_FORECAST_C.Purge_Partial;

205: -- 06-20-02 S Kung Created
206: -- Arguments
207: -- None
208: -- Example
209: -- result := FII_BUDGET_FORECAST_C.Purge_Partial;
210: -- Notes
211: --
212: FUNCTION Purge_Partial RETURN BOOLEAN IS
213: FIIBUUP_fatal_err EXCEPTION;

Line 222: FII_MESSAGE.Func_Ent('FII_BUDGET_FORECAST_C.Purge_Partial');

218:
219: BEGIN
220:
221: IF (FIIBUUP_DEBUG) THEN
222: FII_MESSAGE.Func_Ent('FII_BUDGET_FORECAST_C.Purge_Partial');
223: END IF;
224:
225: -- Check if the specified time period is valid
226: IF (FIIBUUP_DEBUG) THEN

Line 368: v1 => 'FII_BUDGET_FORECAST_C.Purge_Partial()',

364: FII_MESSAGE.Write_Log
365: (msg_name => 'FII_ROUTINE_VAL',
366: token_num => 3 ,
367: t1 => 'ROUTINE',
368: v1 => 'FII_BUDGET_FORECAST_C.Purge_Partial()',
369: t2 => 'VARIABLE',
370: v2 => 'l_sqlstmt',
371: t3 => 'VALUE',
372: v3 => l_sqlstmt);

Line 378: v1 => 'FII_BUDGET_FORECAST_C.Purge_Partial()',

374: FII_MESSAGE.Write_Log
375: (msg_name => 'FII_ROUTINE_VAL',
376: token_num => 3 ,
377: t1 => 'ROUTINE',
378: v1 => 'FII_BUDGET_FORECAST_C.Purge_Partial()',
379: t2 => 'VARIABLE',
380: v2 => 'LENGTH(l_sqlstmt)',
381: t3 => 'VALUE',
382: v3 => TO_CHAR(LENGTH(l_sqlstmt)));

Line 455: FII_MESSAGE.Func_Succ('FII_BUDGET_FORECAST_C.Purge_Partial');

451: -- Commit all work
452: FND_CONCURRENT.Af_Commit;
453:
454: IF (FIIBUUP_DEBUG) THEN
455: FII_MESSAGE.Func_Succ('FII_BUDGET_FORECAST_C.Purge_Partial');
456: END IF;
457: RETURN TRUE;
458:
459: -- Exception handling

Line 469: v1 => 'FII_BUDGET_FORECAST_C.Purge_Partial()');

465: FII_MESSAGE.Write_Log
466: (msg_name => 'FII_ERR_ENC_ROUT',
467: token_num => 1,
468: t1 => 'ROUTINE_NAME',
469: v1 => 'FII_BUDGET_FORECAST_C.Purge_Partial()');
470:
471: FII_MESSAGE.Func_Fail
472: (func_name =>'FII_BUDGET_FORECAST_C.Purge_Partial');
473:

Line 472: (func_name =>'FII_BUDGET_FORECAST_C.Purge_Partial');

468: t1 => 'ROUTINE_NAME',
469: v1 => 'FII_BUDGET_FORECAST_C.Purge_Partial()');
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:

Line 487: v1 => 'FII_BUDGET_FORECAST_C.Purge_Partial()',

483: FII_MESSAGE.Write_Log
484: (msg_name => 'FII_ERROR',
485: token_num => 2,
486: t1 => 'FUNCTION',
487: v1 => 'FII_BUDGET_FORECAST_C.Purge_Partial()',
488: t2 => 'SQLERRMC',
489: v2 => SQLERRM);
490:
491: FII_MESSAGE.Func_Fail

Line 492: (func_name => 'FII_BUDGET_FORECAST_C.Purge_Partial');

488: t2 => 'SQLERRMC',
489: v2 => SQLERRM);
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:

Line 511: -- result := FII_BUDGET_FORECAST_C.Purge_Eff_Date(version_date);

507: -- equal to or greater then the given version date.
508: -- Arguments
509: -- None
510: -- Example
511: -- result := FII_BUDGET_FORECAST_C.Purge_Eff_Date(version_date);
512: -- Notes
513: --
514: FUNCTION Purge_Eff_Date (version_date DATE) RETURN BOOLEAN IS
515: FIIBUUP_fatal_err EXCEPTION;

Line 521: FII_MESSAGE.Func_Ent('FII_BUDGET_FORECAST_C.Purge_Eff_Date');

517:
518: BEGIN
519:
520: IF (FIIBUUP_DEBUG) THEN
521: FII_MESSAGE.Func_Ent('FII_BUDGET_FORECAST_C.Purge_Eff_Date');
522: END IF;
523:
524: -- Purge all records from FII_BUDGET_BASE for the specified effective
525: -- dates. All records with the same dimensions on and after the effective

Line 558: v1 => 'FII_BUDGET_FORECAST_C.purge_eff_date()',

554: FII_MESSAGE.Write_Log
555: (msg_name => 'FII_ROUTINE_VAL',
556: token_num => 3 ,
557: t1 => 'ROUTINE',
558: v1 => 'FII_BUDGET_FORECAST_C.purge_eff_date()',
559: t2 => 'VARIABLE',
560: v2 => 'l_tmpstmt',
561: t3 => 'VALUE',
562: v3 => l_tmpstmt);

Line 568: v1 => 'FII_BUDGET_FORECAST_C.purge_eff_date()',

564: FII_MESSAGE.Write_Log
565: (msg_name => 'FII_ROUTINE_VAL',
566: token_num => 3 ,
567: t1 => 'ROUTINE',
568: v1 => 'FII_BUDGET_FORECAST_C.purge_eff_date()',
569: t2 => 'VARIABLE',
570: v2 => 'LENGTH(l_tmpstmt)',
571: t3 => 'VALUE',
572: v3 => TO_CHAR(LENGTH(l_tmpstmt)));

Line 677: FII_MESSAGE.Func_Succ('FII_BUDGET_FORECAST_C.Purge_Eff_Date');

673: -- Commit everything to database before returning
674: FND_CONCURRENT.Af_Commit;
675:
676: IF (FIIBUUP_DEBUG) THEN
677: FII_MESSAGE.Func_Succ('FII_BUDGET_FORECAST_C.Purge_Eff_Date');
678: END IF;
679: RETURN TRUE;
680:
681: -- Exception handling

Line 691: v1 => 'FII_BUDGET_FORECAST_C.Purge_Eff_Date()');

687: FII_MESSAGE.Write_Log
688: (msg_name => 'FII_ERR_ENC_ROUT',
689: token_num => 1,
690: t1 => 'ROUTINE_NAME',
691: v1 => 'FII_BUDGET_FORECAST_C.Purge_Eff_Date()');
692:
693:
694: FII_MESSAGE.Func_Fail
695: (func_name =>'FII_BUDGET_FORECAST_C.Purge_Eff_Date');

Line 695: (func_name =>'FII_BUDGET_FORECAST_C.Purge_Eff_Date');

691: v1 => 'FII_BUDGET_FORECAST_C.Purge_Eff_Date()');
692:
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:

Line 710: v1 => 'FII_BUDGET_FORECAST_C.Purge_Eff_Date()',

706: FII_MESSAGE.Write_Log
707: (msg_name => 'FII_ERROR',
708: token_num => 2,
709: t1 => 'FUNCTION',
710: v1 => 'FII_BUDGET_FORECAST_C.Purge_Eff_Date()',
711: t2 => 'SQLERRMC',
712: v2 => SQLERRM);
713:
714: FII_MESSAGE.Func_Fail

Line 715: (func_name => 'FII_BUDGET_FORECAST_C.Purge_Eff_Date');

711: t2 => 'SQLERRMC',
712: v2 => SQLERRM);
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:

Line 735: -- result := FII_BUDGET_FORECAST_C.Psi_Insert_Stg

731: -- and insert them into fii_budget_stg.
732: -- Arguments
733: -- None
734: -- Example
735: -- result := FII_BUDGET_FORECAST_C.Psi_Insert_Stg
736: -- Notes
737: -- Returns a boolean indicating if execution completes successfully
738: --
739: FUNCTION Psi_Insert_Stg RETURN BOOLEAN IS

Line 747: FII_MESSAGE.Func_Ent('FII_BUDGET_FORECAST_C.Psi_Insert_Stg');

743:
744: BEGIN
745:
746: IF (FIIBUUP_DEBUG) THEN
747: FII_MESSAGE.Func_Ent('FII_BUDGET_FORECAST_C.Psi_Insert_Stg');
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';

Line 912: v1 => 'FII_BUDGET_FORECAST_C.Psi_Insert_Stg()',

908: FII_MESSAGE.Write_Log
909: (msg_name => 'FII_ROUTINE_VAL',
910: token_num => 3 ,
911: t1 => 'ROUTINE',
912: v1 => 'FII_BUDGET_FORECAST_C.Psi_Insert_Stg()',
913: t2 => 'VARIABLE',
914: v2 => 'LENGTH(l_sqlstmt)',
915: t3 => 'VALUE',
916: v3 => TO_CHAR(LENGTH(l_sqlstmt)));

Line 954: FII_MESSAGE.Func_Succ('FII_BUDGET_FORECAST_C.Psi_Insert_Stg');

950: v2 => 'PSI Insert Stage completed successfully...');
951: END IF;
952:
953: IF (FIIBUUP_DEBUG) THEN
954: FII_MESSAGE.Func_Succ('FII_BUDGET_FORECAST_C.Psi_Insert_Stg');
955: END IF;
956: RETURN TRUE;
957:
958: -- Exception handling

Line 967: v1 => 'FII_BUDGET_FORECAST_C.Psi_Insert_Stg()');

963: FII_MESSAGE.Write_Log
964: (msg_name => 'FII_ERR_ENC_ROUT',
965: token_num => 1,
966: t1 => 'ROUTINE_NAME',
967: v1 => 'FII_BUDGET_FORECAST_C.Psi_Insert_Stg()');
968:
969: FII_MESSAGE.Func_Fail
970: (func_name =>'FII_BUDGET_FORECAST_C.Psi_Insert_Stg');
971:

Line 970: (func_name =>'FII_BUDGET_FORECAST_C.Psi_Insert_Stg');

966: t1 => 'ROUTINE_NAME',
967: v1 => 'FII_BUDGET_FORECAST_C.Psi_Insert_Stg()');
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;

Line 983: v1 => 'FII_BUDGET_FORECAST_C.Psi_Insert_Stg()',

979: FII_MESSAGE.Write_Log
980: (msg_name => 'FII_ERROR',
981: token_num => 2,
982: t1 => 'FUNCTION',
983: v1 => 'FII_BUDGET_FORECAST_C.Psi_Insert_Stg()',
984: t2 => 'SQLERRMC',
985: v2 => SQLERRM);
986:
987: FII_MESSAGE.Func_Fail

Line 988: (func_name => 'FII_BUDGET_FORECAST_C.Psi_Insert_Stg');

984: t2 => 'SQLERRMC',
985: v2 => SQLERRM);
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;

Line 1007: -- result := FII_BUDGET_FORECAST_C.Psi_Carry_Forward

1003: -- are updated in gl_balances directly without any journals.
1004: -- Arguments
1005: -- None
1006: -- Example
1007: -- result := FII_BUDGET_FORECAST_C.Psi_Carry_Forward
1008: -- Notes
1009: -- Returns a boolean indicating if execution completes successfully
1010: --
1011: FUNCTION Psi_Carry_Forward RETURN BOOLEAN IS

Line 1019: FII_MESSAGE.Func_Ent('FII_BUDGET_FORECAST_C.Psi_Carry_Forward');

1015:
1016: BEGIN
1017:
1018: IF (FIIBUUP_DEBUG) THEN
1019: FII_MESSAGE.Func_Ent('FII_BUDGET_FORECAST_C.Psi_Carry_Forward');
1020: END IF;
1021:
1022: -- Check if UDD1 is enabled or not
1023: SELECT DBI_ENABLED_FLAG

Line 1130: v1 => 'FII_BUDGET_FORECAST_C.Psi_Carry_Forward()',

1126: FII_MESSAGE.Write_Log
1127: (msg_name => 'FII_ROUTINE_VAL',
1128: token_num => 3 ,
1129: t1 => 'ROUTINE',
1130: v1 => 'FII_BUDGET_FORECAST_C.Psi_Carry_Forward()',
1131: t2 => 'VARIABLE',
1132: v2 => 'LENGTH(l_sqlstmt)',
1133: t3 => 'VALUE',
1134: v3 => TO_CHAR(LENGTH(l_sqlstmt)));

Line 1172: FII_MESSAGE.Func_Succ('FII_BUDGET_FORECAST_C.Psi_Carry_Forward');

1168: v2 => 'PSI Carry Forward completed successfully...');
1169: END IF;
1170:
1171: IF (FIIBUUP_DEBUG) THEN
1172: FII_MESSAGE.Func_Succ('FII_BUDGET_FORECAST_C.Psi_Carry_Forward');
1173: END IF;
1174: RETURN TRUE;
1175:
1176: -- Exception handling

Line 1185: v1 => 'FII_BUDGET_FORECAST_C.Psi_Carry_Forward()');

1181: FII_MESSAGE.Write_Log
1182: (msg_name => 'FII_ERR_ENC_ROUT',
1183: token_num => 1,
1184: t1 => 'ROUTINE_NAME',
1185: v1 => 'FII_BUDGET_FORECAST_C.Psi_Carry_Forward()');
1186:
1187: FII_MESSAGE.Func_Fail
1188: (func_name =>'FII_BUDGET_FORECAST_C.Psi_Carry_Forward');
1189:

Line 1188: (func_name =>'FII_BUDGET_FORECAST_C.Psi_Carry_Forward');

1184: t1 => 'ROUTINE_NAME',
1185: v1 => 'FII_BUDGET_FORECAST_C.Psi_Carry_Forward()');
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;

Line 1201: v1 => 'FII_BUDGET_FORECAST_C.Psi_Carry_Forward()',

1197: FII_MESSAGE.Write_Log
1198: (msg_name => 'FII_ERROR',
1199: token_num => 2,
1200: t1 => 'FUNCTION',
1201: v1 => 'FII_BUDGET_FORECAST_C.Psi_Carry_Forward()',
1202: t2 => 'SQLERRMC',
1203: v2 => SQLERRM);
1204:
1205: FII_MESSAGE.Func_Fail

Line 1206: (func_name => 'FII_BUDGET_FORECAST_C.Psi_Carry_Forward');

1202: t2 => 'SQLERRMC',
1203: v2 => SQLERRM);
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;

Line 1225: -- result := FII_BUDGET_FORECAST_C.Psi_Rollup;

1221: -- along the time dimension.
1222: -- Arguments
1223: -- None
1224: -- Example
1225: -- result := FII_BUDGET_FORECAST_C.Psi_Rollup;
1226: -- Notes
1227: -- Returns a boolean indicating if execution completes successfully
1228: --
1229: FUNCTION Psi_Rollup RETURN BOOLEAN IS

Line 1236: FII_MESSAGE.Func_Ent('FII_BUDGET_FORECAST_C.Psi_Rollup');

1232:
1233: BEGIN
1234:
1235: IF (FIIBUUP_DEBUG) THEN
1236: FII_MESSAGE.Func_Ent('FII_BUDGET_FORECAST_C.Psi_Rollup');
1237: END IF;
1238:
1239: g_phase := 'PSI Rollup';
1240:

Line 1287: v1 => 'FII_BUDGET_FORECAST_C.Psi_Rollup()',

1283: FII_MESSAGE.Write_Log
1284: (msg_name => 'FII_ROUTINE_VAL',
1285: token_num => 3 ,
1286: t1 => 'ROUTINE',
1287: v1 => 'FII_BUDGET_FORECAST_C.Psi_Rollup()',
1288: t2 => 'VARIABLE',
1289: v2 => 'LENGTH(l_sqlstmt)',
1290: t3 => 'VALUE',
1291: v3 => TO_CHAR(LENGTH(l_sqlstmt)));

Line 1317: FII_MESSAGE.Func_Succ('FII_BUDGET_FORECAST_C.Psi_Rollup');

1313: v2 => 'PSI Rollup completed successfully...');
1314: END IF;
1315:
1316: IF (FIIBUUP_DEBUG) THEN
1317: FII_MESSAGE.Func_Succ('FII_BUDGET_FORECAST_C.Psi_Rollup');
1318: END IF;
1319: RETURN TRUE;
1320:
1321: -- Exception handling

Line 1330: v1 => 'FII_BUDGET_FORECAST_C.Psi_Rollup()');

1326: FII_MESSAGE.Write_Log
1327: (msg_name => 'FII_ERR_ENC_ROUT',
1328: token_num => 1,
1329: t1 => 'ROUTINE_NAME',
1330: v1 => 'FII_BUDGET_FORECAST_C.Psi_Rollup()');
1331:
1332: FII_MESSAGE.Func_Fail
1333: (func_name =>'FII_BUDGET_FORECAST_C.Psi_Rollup');
1334:

Line 1333: (func_name =>'FII_BUDGET_FORECAST_C.Psi_Rollup');

1329: t1 => 'ROUTINE_NAME',
1330: v1 => 'FII_BUDGET_FORECAST_C.Psi_Rollup()');
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;

Line 1346: v1 => 'FII_BUDGET_FORECAST_C.Psi_Rollup()',

1342: FII_MESSAGE.Write_Log
1343: (msg_name => 'FII_ERROR',
1344: token_num => 2,
1345: t1 => 'FUNCTION',
1346: v1 => 'FII_BUDGET_FORECAST_C.Psi_Rollup()',
1347: t2 => 'SQLERRMC',
1348: v2 => SQLERRM);
1349:
1350: FII_MESSAGE.Func_Fail

Line 1351: (func_name => 'FII_BUDGET_FORECAST_C.Psi_Rollup');

1347: t2 => 'SQLERRMC',
1348: v2 => SQLERRM);
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;

Line 1369: -- result := FII_BUDGET_FORECAST_C.Psi_DeleteDiff;

1365: -- that exists in fii_budget_base but not in fii_budget_stg (new data).
1366: -- Arguments
1367: -- None
1368: -- Example
1369: -- result := FII_BUDGET_FORECAST_C.Psi_DeleteDiff;
1370: -- Notes
1371: -- Returns a boolean indicating if execution completes successfully
1372: --
1373: FUNCTION Psi_DeleteDiff RETURN BOOLEAN IS

Line 1380: FII_MESSAGE.Func_Ent('FII_BUDGET_FORECAST_C.Psi_DeleteDiff');

1376:
1377: BEGIN
1378:
1379: IF (FIIBUUP_DEBUG) THEN
1380: FII_MESSAGE.Func_Ent('FII_BUDGET_FORECAST_C.Psi_DeleteDiff');
1381: END IF;
1382:
1383: g_phase := 'PSI DeleteDiff';
1384:

Line 1461: v1 => 'FII_BUDGET_FORECAST_C.Psi_DeleteDiff()',

1457: FII_MESSAGE.Write_Log
1458: (msg_name => 'FII_ROUTINE_VAL',
1459: token_num => 3 ,
1460: t1 => 'ROUTINE',
1461: v1 => 'FII_BUDGET_FORECAST_C.Psi_DeleteDiff()',
1462: t2 => 'VARIABLE',
1463: v2 => 'LENGTH(l_sqlstmt)',
1464: t3 => 'VALUE',
1465: v3 => TO_CHAR(LENGTH(l_sqlstmt)));

Line 1491: FII_MESSAGE.Func_Succ('FII_BUDGET_FORECAST_C.Psi_DeleteDiff');

1487: v2 => 'PSI DeleteDiff completed successfully...');
1488: END IF;
1489:
1490: IF (FIIBUUP_DEBUG) THEN
1491: FII_MESSAGE.Func_Succ('FII_BUDGET_FORECAST_C.Psi_DeleteDiff');
1492: END IF;
1493: RETURN TRUE;
1494:
1495: -- Exception handling

Line 1504: v1 => 'FII_BUDGET_FORECAST_C.Psi_DeleteDiff()');

1500: FII_MESSAGE.Write_Log
1501: (msg_name => 'FII_ERR_ENC_ROUT',
1502: token_num => 1,
1503: t1 => 'ROUTINE_NAME',
1504: v1 => 'FII_BUDGET_FORECAST_C.Psi_DeleteDiff()');
1505:
1506: FII_MESSAGE.Func_Fail
1507: (func_name =>'FII_BUDGET_FORECAST_C.Psi_DeleteDiff');
1508:

Line 1507: (func_name =>'FII_BUDGET_FORECAST_C.Psi_DeleteDiff');

1503: t1 => 'ROUTINE_NAME',
1504: v1 => 'FII_BUDGET_FORECAST_C.Psi_DeleteDiff()');
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;

Line 1520: v1 => 'FII_BUDGET_FORECAST_C.Psi_DeleteDiff()',

1516: FII_MESSAGE.Write_Log
1517: (msg_name => 'FII_ERROR',
1518: token_num => 2,
1519: t1 => 'FUNCTION',
1520: v1 => 'FII_BUDGET_FORECAST_C.Psi_DeleteDiff()',
1521: t2 => 'SQLERRMC',
1522: v2 => SQLERRM);
1523:
1524: FII_MESSAGE.Func_Fail

Line 1525: (func_name => 'FII_BUDGET_FORECAST_C.Psi_DeleteDiff');

1521: t2 => 'SQLERRMC',
1522: v2 => SQLERRM);
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;

Line 1543: -- result := FII_BUDGET_FORECAST_C.Psi_Insert_Base;

1539: -- into fii_budget_base.
1540: -- Arguments
1541: -- None
1542: -- Example
1543: -- result := FII_BUDGET_FORECAST_C.Psi_Insert_Base;
1544: -- Notes
1545: -- Returns a boolean indicating if execution completes successfully
1546: --
1547: FUNCTION Psi_Insert_Base RETURN BOOLEAN IS

Line 1554: FII_MESSAGE.Func_Ent('FII_BUDGET_FORECAST_C.Psi_Insert_Base');

1550:
1551: BEGIN
1552:
1553: IF (FIIBUUP_DEBUG) THEN
1554: FII_MESSAGE.Func_Ent('FII_BUDGET_FORECAST_C.Psi_Insert_Base');
1555: END IF;
1556:
1557: g_phase := 'PSI Insert Base';
1558:

Line 1634: v1 => 'FII_BUDGET_FORECAST_C.Psi_Insert_Base()',

1630: FII_MESSAGE.Write_Log
1631: (msg_name => 'FII_ROUTINE_VAL',
1632: token_num => 3 ,
1633: t1 => 'ROUTINE',
1634: v1 => 'FII_BUDGET_FORECAST_C.Psi_Insert_Base()',
1635: t2 => 'VARIABLE',
1636: v2 => 'LENGTH(l_sqlstmt)',
1637: t3 => 'VALUE',
1638: v3 => TO_CHAR(LENGTH(l_sqlstmt)));

Line 1668: FII_MESSAGE.Func_Succ('FII_BUDGET_FORECAST_C.Psi_Insert_Base');

1664: v2 => 'PSI Merge completed successfully...');
1665: END IF;
1666:
1667: IF (FIIBUUP_DEBUG) THEN
1668: FII_MESSAGE.Func_Succ('FII_BUDGET_FORECAST_C.Psi_Insert_Base');
1669: END IF;
1670: RETURN TRUE;
1671:
1672: -- Exception handling

Line 1681: v1 => 'FII_BUDGET_FORECAST_C.Psi_Insert_Base()');

1677: FII_MESSAGE.Write_Log
1678: (msg_name => 'FII_ERR_ENC_ROUT',
1679: token_num => 1,
1680: t1 => 'ROUTINE_NAME',
1681: v1 => 'FII_BUDGET_FORECAST_C.Psi_Insert_Base()');
1682:
1683: FII_MESSAGE.Func_Fail
1684: (func_name =>'FII_BUDGET_FORECAST_C.Psi_Insert_Base');
1685:

Line 1684: (func_name =>'FII_BUDGET_FORECAST_C.Psi_Insert_Base');

1680: t1 => 'ROUTINE_NAME',
1681: v1 => 'FII_BUDGET_FORECAST_C.Psi_Insert_Base()');
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;

Line 1697: v1 => 'FII_BUDGET_FORECAST_C.Psi_Insert_Base()',

1693: FII_MESSAGE.Write_Log
1694: (msg_name => 'FII_ERROR',
1695: token_num => 2,
1696: t1 => 'FUNCTION',
1697: v1 => 'FII_BUDGET_FORECAST_C.Psi_Insert_Base()',
1698: t2 => 'SQLERRMC',
1699: v2 => SQLERRM);
1700:
1701: FII_MESSAGE.Func_Fail

Line 1702: (func_name => 'FII_BUDGET_FORECAST_C.Psi_Insert_Base');

1698: t2 => 'SQLERRMC',
1699: v2 => SQLERRM);
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;

Line 1720: -- result := FII_BUDGET_FORECAST_C.Psi_Budget_Extract;

1716: -- routine will be called to extract budget data from gl_je_headers/lines.
1717: -- Arguments
1718: -- None
1719: -- Example
1720: -- result := FII_BUDGET_FORECAST_C.Psi_Budget_Extract;
1721: -- Notes
1722: -- Returns a boolean indicating if execution completes successfully
1723: --
1724: PROCEDURE Psi_Budget_Extract (retcode IN OUT NOCOPY VARCHAR2) IS

Line 1801: FII_MESSAGE.Func_Ent('FII_BUDGET_FORECAST_C.Psi_Budget_Extract');

1797: l_status VARCHAR2(1);
1798: BEGIN
1799:
1800: IF (FIIBUUP_DEBUG) THEN
1801: FII_MESSAGE.Func_Ent('FII_BUDGET_FORECAST_C.Psi_Budget_Extract');
1802: END IF;
1803:
1804: -- Alter session comments recommendated by the performance team
1805: EXECUTE IMMEDIATE 'ALTER SESSION ENABLE PARALLEL DML';

Line 1854: IF (NOT FII_BUDGET_FORECAST_C.Psi_Insert_Stg) THEN

1850:
1851: ------------------------------------------------------------------------
1852: -- Insert budget data into FII_BUDGET_STG from gl_je_headers/lines
1853: ------------------------------------------------------------------------
1854: IF (NOT FII_BUDGET_FORECAST_C.Psi_Insert_Stg) THEN
1855: raise FIIBUUP_fatal_err;
1856: END IF;
1857:
1858: ------------------------------------------------------------------------

Line 1861: IF (NOT FII_BUDGET_FORECAST_C.Psi_Carry_Forward) THEN

1857:
1858: ------------------------------------------------------------------------
1859: -- Insert carry forward budget data into FII_BUDGET_STG from gl_balances
1860: ------------------------------------------------------------------------
1861: IF (NOT FII_BUDGET_FORECAST_C.Psi_Carry_Forward) THEN
1862: raise FIIBUUP_fatal_err;
1863: END IF;
1864:
1865: ------------------------------------------------------------------------

Line 1894: IF (NOT FII_BUDGET_FORECAST_C.Psi_Rollup) THEN

1890:
1891: ------------------------------------------------------------------------
1892: -- Rollup budget data along time dimension
1893: ------------------------------------------------------------------------
1894: IF (NOT FII_BUDGET_FORECAST_C.Psi_Rollup) THEN
1895: raise FIIBUUP_fatal_err;
1896: END IF;
1897:
1898: ------------------------------------------------------------------------

Line 1925: IF (NOT FII_BUDGET_FORECAST_C.Psi_DeleteDiff) THEN

1921:
1922: ------------------------------------------------------------------------
1923: -- Delete time/dimension combination not exists in new data in fii_budget_stg
1924: ------------------------------------------------------------------------
1925: IF (NOT FII_BUDGET_FORECAST_C.Psi_DeleteDiff) THEN
1926: raise FIIBUUP_fatal_err;
1927: END IF;
1928:
1929: -- Bug 5004852: Populate CCC - Mgr mappings temp table before opening the

Line 1964: IF (NOT FII_BUDGET_FORECAST_C.Psi_Insert_Base) THEN

1960:
1961: ------------------------------------------------------------------------
1962: -- Merge data in fii_budget_stg into fii_budget_base
1963: ------------------------------------------------------------------------
1964: IF (NOT FII_BUDGET_FORECAST_C.Psi_Insert_Base) THEN
1965: raise FIIBUUP_fatal_err;
1966: END IF;
1967:
1968: ------------------------------------------------------------------------

Line 1997: FII_MESSAGE.Func_Succ('FII_BUDGET_FORECAST_C.Psi_Budget_Extract');

1993: v2 => 'PSI Budget Extraction completed successfully...');
1994: END IF;
1995:
1996: IF (FIIBUUP_DEBUG) THEN
1997: FII_MESSAGE.Func_Succ('FII_BUDGET_FORECAST_C.Psi_Budget_Extract');
1998: END IF;
1999:
2000: -- Exception handling
2001: EXCEPTION

Line 2010: v1 => 'FII_BUDGET_FORECAST_C.Psi_Budget_Extract()');

2006: FII_MESSAGE.Write_Log
2007: (msg_name => 'FII_ERR_ENC_ROUT',
2008: token_num => 1,
2009: t1 => 'ROUTINE_NAME',
2010: v1 => 'FII_BUDGET_FORECAST_C.Psi_Budget_Extract()');
2011:
2012: FII_MESSAGE.Func_Fail
2013: (func_name =>'FII_BUDGET_FORECAST_C.Psi_Budget_Extract');
2014:

Line 2013: (func_name =>'FII_BUDGET_FORECAST_C.Psi_Budget_Extract');

2009: t1 => 'ROUTINE_NAME',
2010: v1 => 'FII_BUDGET_FORECAST_C.Psi_Budget_Extract()');
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:

Line 2028: v1 => 'FII_BUDGET_FORECAST_C.Psi_Budget_Extract()',

2024: FII_MESSAGE.Write_Log
2025: (msg_name => 'FII_ERROR',
2026: token_num => 2,
2027: t1 => 'FUNCTION',
2028: v1 => 'FII_BUDGET_FORECAST_C.Psi_Budget_Extract()',
2029: t2 => 'SQLERRMC',
2030: v2 => SQLERRM);
2031:
2032: FII_MESSAGE.Func_Fail

Line 2033: (func_name => 'FII_BUDGET_FORECAST_C.Psi_Budget_Extract');

2029: t2 => 'SQLERRMC',
2030: v2 => SQLERRM);
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:

Line 2053: -- result := FII_BUDGET_FORECAST_C.Id_Convert;

2049: -- and they insert flex values for the dimensional columns.
2050: -- Arguments
2051: -- None
2052: -- Example
2053: -- result := FII_BUDGET_FORECAST_C.Id_Convert;
2054: -- Notes
2055: -- Returns a boolean indicating if execution completes successfully
2056: --
2057: FUNCTION Id_Convert RETURN BOOLEAN IS

Line 2178: FII_MESSAGE.Func_Ent('FII_BUDGET_FORECAST_C.Id_Convert');

2174: l_status VARCHAR2(1) := null;
2175:
2176: BEGIN
2177: IF (FIIBUUP_DEBUG) THEN
2178: FII_MESSAGE.Func_Ent('FII_BUDGET_FORECAST_C.Id_Convert');
2179: END IF;
2180:
2181: ----------------------------------------------------
2182: -- Populate CCC - Mgr mappings temp table

Line 2327: FII_MESSAGE.Func_Succ('FII_BUDGET_FORECAST_C.Id_Convert');

2323: v2 => 'Value to ID Conversion completed successfully...');
2324: END IF;
2325:
2326: IF (FIIBUUP_DEBUG) THEN
2327: FII_MESSAGE.Func_Succ('FII_BUDGET_FORECAST_C.Id_Convert');
2328: END IF;
2329: RETURN TRUE;
2330:
2331: -- Exception handling

Line 2341: v1 => 'FII_BUDGET_FORECAST_C.Id_Convert()');

2337: FII_MESSAGE.Write_Log
2338: (msg_name => 'FII_ERR_ENC_ROUT',
2339: token_num => 1,
2340: t1 => 'ROUTINE_NAME',
2341: v1 => 'FII_BUDGET_FORECAST_C.Id_Convert()');
2342:
2343: FII_MESSAGE.Func_Fail
2344: (func_name =>'FII_BUDGET_FORECAST_C.Id_Convert');
2345:

Line 2344: (func_name =>'FII_BUDGET_FORECAST_C.Id_Convert');

2340: t1 => 'ROUTINE_NAME',
2341: v1 => 'FII_BUDGET_FORECAST_C.Id_Convert()');
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:

Line 2359: v1 => 'FII_BUDGET_FORECAST_C.Id_Convert()',

2355: FII_MESSAGE.Write_Log
2356: (msg_name => 'FII_ERROR',
2357: token_num => 2,
2358: t1 => 'FUNCTION',
2359: v1 => 'FII_BUDGET_FORECAST_C.Id_Convert()',
2360: t2 => 'SQLERRMC',
2361: v2 => SQLERRM);
2362:
2363: FII_MESSAGE.Func_Fail

Line 2364: (func_name => 'FII_BUDGET_FORECAST_C.Id_Convert');

2360: t2 => 'SQLERRMC',
2361: v2 => SQLERRM);
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:

Line 2404: -- result := FII_BUDGET_FORECAST_C.Validate;

2400: --
2401: -- Arguments
2402: -- None
2403: -- Example
2404: -- result := FII_BUDGET_FORECAST_C.Validate;
2405: -- Notes
2406: -- Returns a boolean indicating if execution completes successfully
2407: PROCEDURE Validate (retcode IN OUT NOCOPY VARCHAR2) IS
2408: TYPE anyCursor IS REF CURSOR;

Line 2729: FII_MESSAGE.Func_Ent('FII_BUDGET_FORECAST_C.Validate');

2725:
2726: BEGIN
2727:
2728: IF (FIIBUUP_DEBUG) THEN
2729: FII_MESSAGE.Func_Ent('FII_BUDGET_FORECAST_C.Validate');
2730: END IF;
2731:
2732: retcode := 'S';
2733:

Line 2937: v1 => 'FII_BUDGET_FORECAST_C.Validate()',

2933: FII_MESSAGE.Write_Log
2934: (msg_name => 'FII_ROUTINE_VAL',
2935: token_num => 3 ,
2936: t1 => 'ROUTINE',
2937: v1 => 'FII_BUDGET_FORECAST_C.Validate()',
2938: t2 => 'VARIABLE',
2939: v2 => 'l_sqlstmt',
2940: t3 => 'VALUE',
2941: v3 => l_sqlstmt);

Line 2947: v1 => 'FII_BUDGET_FORECAST_C.Validate()',

2943: FII_MESSAGE.Write_Log
2944: (msg_name => 'FII_ROUTINE_VAL',
2945: token_num => 3 ,
2946: t1 => 'ROUTINE',
2947: v1 => 'FII_BUDGET_FORECAST_C.Validate()',
2948: t2 => 'VARIABLE',
2949: v2 => 'LENGTH(l_sqlstmt)',
2950: t3 => 'VALUE',
2951: v3 => TO_CHAR(LENGTH(l_sqlstmt)));

Line 3027: v1 => 'FII_BUDGET_FORECAST_C.Validate()',

3023: FII_MESSAGE.Write_Log
3024: (msg_name => 'FII_ROUTINE_VAL',
3025: token_num => 3 ,
3026: t1 => 'ROUTINE',
3027: v1 => 'FII_BUDGET_FORECAST_C.Validate()',
3028: t2 => 'VARIABLE',
3029: v2 => 'l_sqlstmt',
3030: t3 => 'VALUE',
3031: v3 => l_sqlstmt);

Line 3037: v1 => 'FII_BUDGET_FORECAST_C.Validate()',

3033: FII_MESSAGE.Write_Log
3034: (msg_name => 'FII_ROUTINE_VAL',
3035: token_num => 3 ,
3036: t1 => 'ROUTINE',
3037: v1 => 'FII_BUDGET_FORECAST_C.Validate()',
3038: t2 => 'VARIABLE',
3039: v2 => 'LENGTH(l_sqlstmt)',
3040: t3 => 'VALUE',
3041: v3 => TO_CHAR(LENGTH(l_sqlstmt)));

Line 3283: IF(NOT FII_BUDGET_FORECAST_C.Id_Convert) THEN

3279: token_num => 0);
3280: raise FIIBUUP_fatal_err;
3281: END IF;
3282:
3283: IF(NOT FII_BUDGET_FORECAST_C.Id_Convert) THEN
3284: raise FIIBUUP_fatal_err;
3285: END IF;
3286:
3287: -----------------------------------------------------------------------

Line 3888: FII_MESSAGE.Func_Succ('FII_BUDGET_FORECAST_C.Validate');

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;
3892:

Line 3905: FII_MESSAGE.Func_Succ('FII_BUDGET_FORECAST_C.Validate');

3901: v2 => 'All validations completed successfully...');
3902: END IF;
3903:
3904: IF (FIIBUUP_DEBUG) THEN
3905: FII_MESSAGE.Func_Succ('FII_BUDGET_FORECAST_C.Validate');
3906: END IF;
3907: RETURN;
3908:
3909: -- Exception handling

Line 3918: v1 => 'FII_BUDGET_FORECAST_C.Validate()');

3914: FII_MESSAGE.Write_Log
3915: (msg_name => 'FII_ERR_ENC_ROUT',
3916: token_num => 1,
3917: t1 => 'ROUTINE_NAME',
3918: v1 => 'FII_BUDGET_FORECAST_C.Validate()');
3919:
3920: FII_MESSAGE.Func_Fail
3921: (func_name =>'FII_BUDGET_FORECAST_C.Validate');
3922:

Line 3921: (func_name =>'FII_BUDGET_FORECAST_C.Validate');

3917: t1 => 'ROUTINE_NAME',
3918: v1 => 'FII_BUDGET_FORECAST_C.Validate()');
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';

Line 3935: v1 => 'FII_BUDGET_FORECAST_C.Validate()',

3931: FII_MESSAGE.Write_Log
3932: (msg_name => 'FII_ERROR',
3933: token_num => 2,
3934: t1 => 'FUNCTION',
3935: v1 => 'FII_BUDGET_FORECAST_C.Validate()',
3936: t2 => 'SQLERRMC',
3937: v2 => SQLERRM);
3938:
3939: FII_MESSAGE.Func_Fail

Line 3940: (func_name => 'FII_BUDGET_FORECAST_C.Validate');

3936: t2 => 'SQLERRMC',
3937: v2 => SQLERRM);
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';

Line 3964: -- result := FII_BUDGET_FORECAST_C.Prior_version(version_date);

3960: --
3961: -- Arguments
3962: -- version_date
3963: -- Example
3964: -- result := FII_BUDGET_FORECAST_C.Prior_version(version_date);
3965: -- Notes
3966: -- Returns a boolean indicating if execution completes successfully
3967: FUNCTION Prior_version (version_date DATE) RETURN BOOLEAN IS
3968: FIIBUUP_fatal_err EXCEPTION;

Line 3981: 'FII_BUDGET_FORECAST_C.Prior_version - version_date = ' ||

3977: BEGIN
3978:
3979: IF (FIIBUUP_DEBUG) THEN
3980: FII_MESSAGE.Func_Ent(
3981: 'FII_BUDGET_FORECAST_C.Prior_version - version_date = ' ||
3982: version_date);
3983: END IF;
3984:
3985: -- Determine which time column should be used

Line 4348: v1 => 'FII_BUDGET_FORECAST_C.Prior_version()',

4344: FII_MESSAGE.Write_Log
4345: (msg_name => 'FII_ROUTINE_VAL',
4346: token_num => 3 ,
4347: t1 => 'ROUTINE',
4348: v1 => 'FII_BUDGET_FORECAST_C.Prior_version()',
4349: t2 => 'VARIABLE',
4350: v2 => 'LENGTH(l_bud_sqlstmt)',
4351: t3 => 'VALUE',
4352: v3 => TO_CHAR(LENGTH(l_bud_sqlstmt)));

Line 4360: v1 => 'FII_BUDGET_FORECAST_C.Prior_version()',

4356: FII_MESSAGE.Write_Log
4357: (msg_name => 'FII_ROUTINE_VAL',
4358: token_num => 3 ,
4359: t1 => 'ROUTINE',
4360: v1 => 'FII_BUDGET_FORECAST_C.Prior_version()',
4361: t2 => 'VARIABLE',
4362: v2 => 'LENGTH(l_fc_sqlstmt)',
4363: t3 => 'VALUE',
4364: v3 => TO_CHAR(LENGTH(l_fc_sqlstmt)));

Line 4406: FII_MESSAGE.Func_Succ('FII_BUDGET_FORECAST_C.Prior_version' ||

4402:
4403: FND_CONCURRENT.Af_Commit;
4404:
4405: IF (FIIBUUP_DEBUG) THEN
4406: FII_MESSAGE.Func_Succ('FII_BUDGET_FORECAST_C.Prior_version' ||
4407: version_date);
4408: END IF;
4409: RETURN TRUE;
4410:

Line 4419: v1 => 'FII_BUDGET_FORECAST_C.Prior_version()');

4415: FII_MESSAGE.Write_Log
4416: (msg_name => 'FII_ERR_ENC_ROUT',
4417: token_num => 1,
4418: t1 => 'ROUTINE_NAME',
4419: v1 => 'FII_BUDGET_FORECAST_C.Prior_version()');
4420:
4421: FII_MESSAGE.Func_Fail
4422: (func_name => 'FII_BUDGET_FORECAST_C.Prior_version');
4423:

Line 4422: (func_name => 'FII_BUDGET_FORECAST_C.Prior_version');

4418: t1 => 'ROUTINE_NAME',
4419: v1 => 'FII_BUDGET_FORECAST_C.Prior_version()');
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;

Line 4435: v1 => 'FII_BUDGET_FORECAST_C.Prior_version',

4431: -- SQL error occurs. Print out the error
4432: FII_MESSAGE.Write_Log(msg_name => 'FII_ERROR',
4433: token_num => 2,
4434: t1 => 'FUNCTION',
4435: v1 => 'FII_BUDGET_FORECAST_C.Prior_version',
4436: t2 => 'SQLERRMC',
4437: v2 => SQLERRM);
4438:
4439: FII_MESSAGE.Func_Fail

Line 4440: (func_name => 'FII_BUDGET_FORECAST_C.Prior_version' || version_date);

4436: t2 => 'SQLERRMC',
4437: v2 => SQLERRM);
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;

Line 4461: -- result := FII_BUDGET_FORECAST_C.Prior_version;

4457: --
4458: -- Arguments
4459: -- version_date
4460: -- Example
4461: -- result := FII_BUDGET_FORECAST_C.Prior_version;
4462: -- Notes
4463: -- Returns a boolean indicating if execution completes successfully
4464: FUNCTION Prior_version RETURN BOOLEAN IS
4465: FIIBUUP_fatal_err EXCEPTION;

Line 4477: FII_MESSAGE.Func_Ent('FII_BUDGET_FORECAST_C.Prior_version');

4473:
4474: BEGIN
4475:
4476: IF (FIIBUUP_DEBUG) THEN
4477: FII_MESSAGE.Func_Ent('FII_BUDGET_FORECAST_C.Prior_version');
4478: END IF;
4479:
4480: -- Determine which time column should be used
4481: IF (FIIBUUP_BUDGET_TIME_UNIT = 'P') THEN

Line 4690: v1 => 'FII_BUDGET_FORECAST_C.Prior_version()',

4686: FII_MESSAGE.Write_Log
4687: (msg_name => 'FII_ROUTINE_VAL',
4688: token_num => 3 ,
4689: t1 => 'ROUTINE',
4690: v1 => 'FII_BUDGET_FORECAST_C.Prior_version()',
4691: t2 => 'VARIABLE',
4692: v2 => 'LENGTH(l_bud_sqlstmt)',
4693: t3 => 'VALUE',
4694: v3 => TO_CHAR(LENGTH(l_bud_sqlstmt)));

Line 4702: v1 => 'FII_BUDGET_FORECAST_C.Prior_version()',

4698: FII_MESSAGE.Write_Log
4699: (msg_name => 'FII_ROUTINE_VAL',
4700: token_num => 3 ,
4701: t1 => 'ROUTINE',
4702: v1 => 'FII_BUDGET_FORECAST_C.Prior_version()',
4703: t2 => 'VARIABLE',
4704: v2 => 'LENGTH(l_fc_sqlstmt)',
4705: t3 => 'VALUE',
4706: v3 => TO_CHAR(LENGTH(l_fc_sqlstmt)));

Line 4742: FII_MESSAGE.Func_Succ('FII_BUDGET_FORECAST_C.Prior_version');

4738:
4739: FND_CONCURRENT.Af_Commit;
4740:
4741: IF (FIIBUUP_DEBUG) THEN
4742: FII_MESSAGE.Func_Succ('FII_BUDGET_FORECAST_C.Prior_version');
4743: END IF;
4744: RETURN TRUE;
4745:
4746: EXCEPTION

Line 4754: v1 => 'FII_BUDGET_FORECAST_C.Prior_version()');

4750: FII_MESSAGE.Write_Log
4751: (msg_name => 'FII_ERR_ENC_ROUT',
4752: token_num => 1,
4753: t1 => 'ROUTINE_NAME',
4754: v1 => 'FII_BUDGET_FORECAST_C.Prior_version()');
4755:
4756: FII_MESSAGE.Func_Fail
4757: (func_name => 'FII_BUDGET_FORECAST_C.Prior_version');
4758:

Line 4757: (func_name => 'FII_BUDGET_FORECAST_C.Prior_version');

4753: t1 => 'ROUTINE_NAME',
4754: v1 => 'FII_BUDGET_FORECAST_C.Prior_version()');
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;

Line 4770: v1 => 'FII_BUDGET_FORECAST_C.Prior_version',

4766: -- SQL error occurs. Print out the error
4767: FII_MESSAGE.Write_Log(msg_name => 'FII_ERROR',
4768: token_num => 2,
4769: t1 => 'FUNCTION',
4770: v1 => 'FII_BUDGET_FORECAST_C.Prior_version',
4771: t2 => 'SQLERRMC',
4772: v2 => SQLERRM);
4773:
4774: FII_MESSAGE.Func_Fail

Line 4775: (func_name => 'FII_BUDGET_FORECAST_C.Prior_version');

4771: t2 => 'SQLERRMC',
4772: v2 => SQLERRM);
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;

Line 4792: -- result := FII_BUDGET_FORECAST_C.Stage(version_date);

4788: -- This routine populates data into fii_budget_stg.
4789: -- Arguments
4790: -- version_date
4791: -- Example
4792: -- result := FII_BUDGET_FORECAST_C.Stage(version_date);
4793: -- Notes
4794: -- Returns a boolean indicating if execution completes successfully
4795: FUNCTION Stage (version_date DATE) RETURN BOOLEAN IS
4796: FIIBUUP_fatal_err EXCEPTION;

Line 4810: FII_MESSAGE.Func_Ent('FII_BUDGET_FORECAST_C.stage - version_date = ' ||

4806:
4807: BEGIN
4808:
4809: IF (FIIBUUP_DEBUG) THEN
4810: FII_MESSAGE.Func_Ent('FII_BUDGET_FORECAST_C.stage - version_date = ' ||
4811: version_date);
4812: END IF;
4813:
4814: -- Determine which time column should be used for staging

Line 5015: v1 => 'FII_BUDGET_FORECAST_C.stage()',

5011: FII_MESSAGE.Write_Log
5012: (msg_name => 'FII_ROUTINE_VAL',
5013: token_num => 3 ,
5014: t1 => 'ROUTINE',
5015: v1 => 'FII_BUDGET_FORECAST_C.stage()',
5016: t2 => 'VARIABLE',
5017: v2 => 'LENGTH(l_bud_sqlstmt)',
5018: t3 => 'VALUE',
5019: v3 => TO_CHAR(LENGTH(l_bud_sqlstmt)));

Line 5027: v1 => 'FII_BUDGET_FORECAST_C.stage()',

5023: FII_MESSAGE.Write_Log
5024: (msg_name => 'FII_ROUTINE_VAL',
5025: token_num => 3 ,
5026: t1 => 'ROUTINE',
5027: v1 => 'FII_BUDGET_FORECAST_C.stage()',
5028: t2 => 'VARIABLE',
5029: v2 => 'LENGTH(l_fc_sqlstmt)',
5030: t3 => 'VALUE',
5031: v3 => TO_CHAR(LENGTH(l_fc_sqlstmt)));

Line 5136: FII_MESSAGE.Func_Succ('FII_BUDGET_FORECAST_C.stage');

5132:
5133: FND_CONCURRENT.Af_Commit;
5134:
5135: IF (FIIBUUP_DEBUG) THEN
5136: FII_MESSAGE.Func_Succ('FII_BUDGET_FORECAST_C.stage');
5137: END IF;
5138: RETURN TRUE;
5139:
5140: EXCEPTION

Line 5148: v1 => 'FII_BUDGET_FORECAST_C.stage()');

5144: FII_MESSAGE.Write_Log
5145: (msg_name => 'FII_ERR_ENC_ROUT',
5146: token_num => 1,
5147: t1 => 'ROUTINE_NAME',
5148: v1 => 'FII_BUDGET_FORECAST_C.stage()');
5149:
5150: FII_MESSAGE.Func_Fail
5151: (func_name => 'FII_BUDGET_FORECAST_C.stage');
5152:

Line 5151: (func_name => 'FII_BUDGET_FORECAST_C.stage');

5147: t1 => 'ROUTINE_NAME',
5148: v1 => 'FII_BUDGET_FORECAST_C.stage()');
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;

Line 5164: v1 => 'FII_BUDGET_FORECAST_C.stage',

5160: -- SQL error occurs. Print out the error
5161: FII_MESSAGE.Write_Log(msg_name => 'FII_ERROR',
5162: token_num => 2,
5163: t1 => 'FUNCTION',
5164: v1 => 'FII_BUDGET_FORECAST_C.stage',
5165: t2 => 'SQLERRMC',
5166: v2 => SQLERRM);
5167:
5168: FII_MESSAGE.Func_Fail

Line 5169: (func_name => 'FII_BUDGET_FORECAST_C.stage');

5165: t2 => 'SQLERRMC',
5166: v2 => SQLERRM);
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;

Line 5188: -- result := FII_BUDGET_FORECAST_C.Adjust_Amount;

5184: -- in fii_budget_base.
5185: -- Arguments
5186: -- version_date
5187: -- Example
5188: -- result := FII_BUDGET_FORECAST_C.Adjust_Amount;
5189: -- Notes
5190: -- Returns a boolean indicating if execution completes successfully
5191: FUNCTION Adjust_Amount RETURN BOOLEAN IS
5192: FIIBUUP_fatal_err EXCEPTION;

Line 5206: FII_MESSAGE.Func_Ent('FII_BUDGET_FORECAST_C.adjust_amount');

5202:
5203: BEGIN
5204:
5205: IF (FIIBUUP_DEBUG) THEN
5206: FII_MESSAGE.Func_Ent('FII_BUDGET_FORECAST_C.adjust_amount');
5207: END IF;
5208:
5209: -- Determine which time column should be used for staging
5210: IF (FIIBUUP_BUDGET_TIME_UNIT = 'P') THEN

Line 5310: v1 => 'FII_BUDGET_FORECAST_C.adjust_amount()',

5306: FII_MESSAGE.Write_Log
5307: (msg_name => 'FII_ROUTINE_VAL',
5308: token_num => 3 ,
5309: t1 => 'ROUTINE',
5310: v1 => 'FII_BUDGET_FORECAST_C.adjust_amount()',
5311: t2 => 'VARIABLE',
5312: v2 => 'LENGTH(l_bud_sqlstmt)',
5313: t3 => 'VALUE',
5314: v3 => TO_CHAR(LENGTH(l_bud_sqlstmt)));

Line 5322: v1 => 'FII_BUDGET_FORECAST_C.adjust_amount()',

5318: FII_MESSAGE.Write_Log
5319: (msg_name => 'FII_ROUTINE_VAL',
5320: token_num => 3 ,
5321: t1 => 'ROUTINE',
5322: v1 => 'FII_BUDGET_FORECAST_C.adjust_amount()',
5323: t2 => 'VARIABLE',
5324: v2 => 'LENGTH(l_fc_sqlstmt)',
5325: t3 => 'VALUE',
5326: v3 => TO_CHAR(LENGTH(l_fc_sqlstmt)));

Line 5460: v1 => 'FII_BUDGET_FORECAST_C.adjust_amount()',

5456: FII_MESSAGE.Write_Log
5457: (msg_name => 'FII_ROUTINE_VAL',
5458: token_num => 3 ,
5459: t1 => 'ROUTINE',
5460: v1 => 'FII_BUDGET_FORECAST_C.adjust_amount()',
5461: t2 => 'VARIABLE',
5462: v2 => 'LENGTH(l_bud_sqlstmt)',
5463: t3 => 'VALUE',
5464: v3 => TO_CHAR(LENGTH(l_bud_sqlstmt)));

Line 5472: v1 => 'FII_BUDGET_FORECAST_C.adjust_amount()',

5468: FII_MESSAGE.Write_Log
5469: (msg_name => 'FII_ROUTINE_VAL',
5470: token_num => 3 ,
5471: t1 => 'ROUTINE',
5472: v1 => 'FII_BUDGET_FORECAST_C.adjust_amount()',
5473: t2 => 'VARIABLE',
5474: v2 => 'LENGTH(l_fc_sqlstmt)',
5475: t3 => 'VALUE',
5476: v3 => TO_CHAR(LENGTH(l_fc_sqlstmt)));

Line 5549: FII_MESSAGE.Func_Succ('FII_BUDGET_FORECAST_C.adjust_amount');

5545:
5546: FND_CONCURRENT.Af_Commit;
5547:
5548: IF (FIIBUUP_DEBUG) THEN
5549: FII_MESSAGE.Func_Succ('FII_BUDGET_FORECAST_C.adjust_amount');
5550: END IF;
5551: RETURN TRUE;
5552:
5553: EXCEPTION

Line 5561: v1 => 'FII_BUDGET_FORECAST_C.adjust_amount()');

5557: FII_MESSAGE.Write_Log
5558: (msg_name => 'FII_ERR_ENC_ROUT',
5559: token_num => 1,
5560: t1 => 'ROUTINE_NAME',
5561: v1 => 'FII_BUDGET_FORECAST_C.adjust_amount()');
5562:
5563: FII_MESSAGE.Func_Fail
5564: (func_name => 'FII_BUDGET_FORECAST_C.adjsut_stage');
5565:

Line 5564: (func_name => 'FII_BUDGET_FORECAST_C.adjsut_stage');

5560: t1 => 'ROUTINE_NAME',
5561: v1 => 'FII_BUDGET_FORECAST_C.adjust_amount()');
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;

Line 5577: v1 => 'FII_BUDGET_FORECAST_C.adjust_amount',

5573: -- SQL error occurs. Print out the error
5574: FII_MESSAGE.Write_Log(msg_name => 'FII_ERROR',
5575: token_num => 2,
5576: t1 => 'FUNCTION',
5577: v1 => 'FII_BUDGET_FORECAST_C.adjust_amount',
5578: t2 => 'SQLERRMC',
5579: v2 => SQLERRM);
5580:
5581: FII_MESSAGE.Func_Fail

Line 5582: (func_name => 'FII_BUDGET_FORECAST_C.adjust_amount');

5578: t2 => 'SQLERRMC',
5579: v2 => SQLERRM);
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;

Line 5600: -- result := FII_BUDGET_FORECAST_C.Rollup_Stage;

5596: -- Rollup records in fii_budget_stg along time dimension.
5597: -- Arguments
5598: -- version_date
5599: -- Example
5600: -- result := FII_BUDGET_FORECAST_C.Rollup_Stage;
5601: -- Notes
5602: -- Returns a boolean indicating if execution completes successfully
5603: FUNCTION Rollup_Stage RETURN BOOLEAN IS
5604: FIIBUUP_fatal_err EXCEPTION;

Line 5618: FII_MESSAGE.Func_Ent('FII_BUDGET_FORECAST_C.rollup_stage');

5614:
5615: BEGIN
5616:
5617: IF (FIIBUUP_DEBUG) THEN
5618: FII_MESSAGE.Func_Ent('FII_BUDGET_FORECAST_C.rollup_stage');
5619: END IF;
5620:
5621: -- Determine which time column should be used for staging
5622: IF (FIIBUUP_BUDGET_TIME_UNIT = 'P') THEN

Line 5749: v1 => 'FII_BUDGET_FORECAST_C.rollup_stage()',

5745: FII_MESSAGE.Write_Log
5746: (msg_name => 'FII_ROUTINE_VAL',
5747: token_num => 3 ,
5748: t1 => 'ROUTINE',
5749: v1 => 'FII_BUDGET_FORECAST_C.rollup_stage()',
5750: t2 => 'VARIABLE',
5751: v2 => 'LENGTH(l_bud_sqlstmt)',
5752: t3 => 'VALUE',
5753: v3 => TO_CHAR(LENGTH(l_bud_sqlstmt)));

Line 5761: v1 => 'FII_BUDGET_FORECAST_C.rollup_stage()',

5757: FII_MESSAGE.Write_Log
5758: (msg_name => 'FII_ROUTINE_VAL',
5759: token_num => 3 ,
5760: t1 => 'ROUTINE',
5761: v1 => 'FII_BUDGET_FORECAST_C.rollup_stage()',
5762: t2 => 'VARIABLE',
5763: v2 => 'LENGTH(l_fc_sqlstmt)',
5764: t3 => 'VALUE',
5765: v3 => TO_CHAR(LENGTH(l_fc_sqlstmt)));

Line 5847: FII_MESSAGE.Func_Succ('FII_BUDGET_FORECAST_C.rollup_stage');

5843:
5844: FND_CONCURRENT.Af_Commit;
5845:
5846: IF (FIIBUUP_DEBUG) THEN
5847: FII_MESSAGE.Func_Succ('FII_BUDGET_FORECAST_C.rollup_stage');
5848: END IF;
5849: RETURN TRUE;
5850:
5851: EXCEPTION

Line 5859: v1 => 'FII_BUDGET_FORECAST_C.rollup_stage()');

5855: FII_MESSAGE.Write_Log
5856: (msg_name => 'FII_ERR_ENC_ROUT',
5857: token_num => 1,
5858: t1 => 'ROUTINE_NAME',
5859: v1 => 'FII_BUDGET_FORECAST_C.rollup_stage()');
5860:
5861: FII_MESSAGE.Func_Fail
5862: (func_name => 'FII_BUDGET_FORECAST_C.rollup_stage');
5863:

Line 5862: (func_name => 'FII_BUDGET_FORECAST_C.rollup_stage');

5858: t1 => 'ROUTINE_NAME',
5859: v1 => 'FII_BUDGET_FORECAST_C.rollup_stage()');
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;

Line 5875: v1 => 'FII_BUDGET_FORECAST_C.rollup_stage',

5871: -- SQL error occurs. Print out the error
5872: FII_MESSAGE.Write_Log(msg_name => 'FII_ERROR',
5873: token_num => 2,
5874: t1 => 'FUNCTION',
5875: v1 => 'FII_BUDGET_FORECAST_C.rollup_stage',
5876: t2 => 'SQLERRMC',
5877: v2 => SQLERRM);
5878:
5879: FII_MESSAGE.Func_Fail

Line 5880: (func_name => 'FII_BUDGET_FORECAST_C.rollup_stage');

5876: t2 => 'SQLERRMC',
5877: v2 => SQLERRM);
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;

Line 5900: -- result := FII_BUDGET_FORECAST_C.Adjust_Stage;

5896: -- time dimension into fii_budget_stg.
5897: -- Arguments
5898: -- version_date
5899: -- Example
5900: -- result := FII_BUDGET_FORECAST_C.Adjust_Stage;
5901: -- Notes
5902: -- Returns a boolean indicating if execution completes successfully
5903: FUNCTION Adjust_Stage RETURN BOOLEAN IS
5904: FIIBUUP_fatal_err EXCEPTION;

Line 5912: FII_MESSAGE.Func_Ent('FII_BUDGET_FORECAST_C.adjust_stage');

5908:
5909: BEGIN
5910:
5911: IF (FIIBUUP_DEBUG) THEN
5912: FII_MESSAGE.Func_Ent('FII_BUDGET_FORECAST_C.adjust_stage');
5913: END IF;
5914:
5915: -- The statment for stage needs to be built dynamically for
5916: -- budget and forecast

Line 5965: v1 => 'FII_BUDGET_FORECAST_C.adjust_stage()',

5961: FII_MESSAGE.Write_Log
5962: (msg_name => 'FII_ROUTINE_VAL',
5963: token_num => 3 ,
5964: t1 => 'ROUTINE',
5965: v1 => 'FII_BUDGET_FORECAST_C.adjust_stage()',
5966: t2 => 'VARIABLE',
5967: v2 => 'LENGTH(l_bud_sqlstmt)',
5968: t3 => 'VALUE',
5969: v3 => TO_CHAR(LENGTH(l_bud_sqlstmt)));

Line 5977: v1 => 'FII_BUDGET_FORECAST_C.adjust_stage()',

5973: FII_MESSAGE.Write_Log
5974: (msg_name => 'FII_ROUTINE_VAL',
5975: token_num => 3 ,
5976: t1 => 'ROUTINE',
5977: v1 => 'FII_BUDGET_FORECAST_C.adjust_stage()',
5978: t2 => 'VARIABLE',
5979: v2 => 'LENGTH(l_fc_sqlstmt)',
5980: t3 => 'VALUE',
5981: v3 => TO_CHAR(LENGTH(l_fc_sqlstmt)));

Line 6046: FII_MESSAGE.Func_Succ('FII_BUDGET_FORECAST_C.adjust_stage');

6042: v2 => 'adjust_stage done...');
6043: END IF;
6044:
6045: IF (FIIBUUP_DEBUG) THEN
6046: FII_MESSAGE.Func_Succ('FII_BUDGET_FORECAST_C.adjust_stage');
6047: END IF;
6048: RETURN TRUE;
6049:
6050: EXCEPTION

Line 6058: v1 => 'FII_BUDGET_FORECAST_C.adjust_stage()');

6054: FII_MESSAGE.Write_Log
6055: (msg_name => 'FII_ERR_ENC_ROUT',
6056: token_num => 1,
6057: t1 => 'ROUTINE_NAME',
6058: v1 => 'FII_BUDGET_FORECAST_C.adjust_stage()');
6059:
6060: FII_MESSAGE.Func_Fail
6061: (func_name => 'FII_BUDGET_FORECAST_C.adjsut_stage');
6062:

Line 6061: (func_name => 'FII_BUDGET_FORECAST_C.adjsut_stage');

6057: t1 => 'ROUTINE_NAME',
6058: v1 => 'FII_BUDGET_FORECAST_C.adjust_stage()');
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;

Line 6074: v1 => 'FII_BUDGET_FORECAST_C.adjust_stage',

6070: -- SQL error occurs. Print out the error
6071: FII_MESSAGE.Write_Log(msg_name => 'FII_ERROR',
6072: token_num => 2,
6073: t1 => 'FUNCTION',
6074: v1 => 'FII_BUDGET_FORECAST_C.adjust_stage',
6075: t2 => 'SQLERRMC',
6076: v2 => SQLERRM);
6077:
6078: FII_MESSAGE.Func_Fail

Line 6079: (func_name => 'FII_BUDGET_FORECAST_C.adjust_stage');

6075: t2 => 'SQLERRMC',
6076: v2 => SQLERRM);
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;

Line 6098: -- result := FII_BUDGET_FORECAST_C.Merge;

6094: -- the new amounts into fii_budget_base.
6095: -- Arguments
6096: -- version_date
6097: -- Example
6098: -- result := FII_BUDGET_FORECAST_C.Merge;
6099: -- Notes
6100: -- Returns a boolean indicating if execution completes successfully
6101: FUNCTION Merge RETURN BOOLEAN IS
6102: FIIBUUP_fatal_err EXCEPTION;

Line 6111: FII_MESSAGE.Func_Ent('FII_BUDGET_FORECAST_C.merge');

6107:
6108: BEGIN
6109:
6110: IF (FIIBUUP_DEBUG) THEN
6111: FII_MESSAGE.Func_Ent('FII_BUDGET_FORECAST_C.merge');
6112: END IF;
6113:
6114: -- The statment for stage needs to be built dynamically for
6115: -- budget and forecast

Line 6207: v1 => 'FII_BUDGET_FORECAST_C.merge()',

6203: FII_MESSAGE.Write_Log
6204: (msg_name => 'FII_ROUTINE_VAL',
6205: token_num => 3 ,
6206: t1 => 'ROUTINE',
6207: v1 => 'FII_BUDGET_FORECAST_C.merge()',
6208: t2 => 'VARIABLE',
6209: v2 => 'LENGTH(l_tmpstmt)',
6210: t3 => 'VALUE',
6211: v3 => TO_CHAR(LENGTH(l_tmpstmt)));

Line 6291: FII_MESSAGE.Func_Succ('FII_BUDGET_FORECAST_C.merge');

6287:
6288: FND_CONCURRENT.Af_Commit;
6289:
6290: IF (FIIBUUP_DEBUG) THEN
6291: FII_MESSAGE.Func_Succ('FII_BUDGET_FORECAST_C.merge');
6292: END IF;
6293: RETURN TRUE;
6294:
6295: EXCEPTION

Line 6303: v1 => 'FII_BUDGET_FORECAST_C.merge()');

6299: FII_MESSAGE.Write_Log
6300: (msg_name => 'FII_ERR_ENC_ROUT',
6301: token_num => 1,
6302: t1 => 'ROUTINE_NAME',
6303: v1 => 'FII_BUDGET_FORECAST_C.merge()');
6304:
6305: FII_MESSAGE.Func_Fail
6306: (func_name => 'FII_BUDGET_FORECAST_C.merge');
6307:

Line 6306: (func_name => 'FII_BUDGET_FORECAST_C.merge');

6302: t1 => 'ROUTINE_NAME',
6303: v1 => 'FII_BUDGET_FORECAST_C.merge()');
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;

Line 6319: v1 => 'FII_BUDGET_FORECAST_C.merge',

6315: -- SQL error occurs. Print out the error
6316: FII_MESSAGE.Write_Log(msg_name => 'FII_ERROR',
6317: token_num => 2,
6318: t1 => 'FUNCTION',
6319: v1 => 'FII_BUDGET_FORECAST_C.merge',
6320: t2 => 'SQLERRMC',
6321: v2 => SQLERRM);
6322:
6323: FII_MESSAGE.Func_Fail

Line 6324: (func_name => 'FII_BUDGET_FORECAST_C.merge');

6320: t2 => 'SQLERRMC',
6321: v2 => SQLERRM);
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;

Line 6344: -- result := FII_BUDGET_FORECAST_C.Adjust_Ver_Date;

6340: -- upload.
6341: -- Arguments
6342: -- version_date
6343: -- Example
6344: -- result := FII_BUDGET_FORECAST_C.Adjust_Ver_Date;
6345: -- Notes
6346: -- Returns a boolean indicating if execution completes successfully
6347: FUNCTION Adjust_Ver_Date RETURN BOOLEAN IS
6348: FIIBUUP_fatal_err EXCEPTION;

Line 6356: FII_MESSAGE.Func_Ent('FII_BUDGET_FORECAST_C.adjust_ver_date');

6352:
6353: BEGIN
6354:
6355: IF (FIIBUUP_DEBUG) THEN
6356: FII_MESSAGE.Func_Ent('FII_BUDGET_FORECAST_C.adjust_ver_date');
6357: END IF;
6358:
6359: -- The statment for stage needs to be built dynamically for
6360: -- budget and forecast

Line 6406: v1 => 'FII_BUDGET_FORECAST_C.adjust_ver_date()',

6402: FII_MESSAGE.Write_Log
6403: (msg_name => 'FII_ROUTINE_VAL',
6404: token_num => 3 ,
6405: t1 => 'ROUTINE',
6406: v1 => 'FII_BUDGET_FORECAST_C.adjust_ver_date()',
6407: t2 => 'VARIABLE',
6408: v2 => 'LENGTH(l_bud_sqlstmt)',
6409: t3 => 'VALUE',
6410: v3 => TO_CHAR(LENGTH(l_bud_sqlstmt)));

Line 6418: v1 => 'FII_BUDGET_FORECAST_C.adjust_ver_date()',

6414: FII_MESSAGE.Write_Log
6415: (msg_name => 'FII_ROUTINE_VAL',
6416: token_num => 3 ,
6417: t1 => 'ROUTINE',
6418: v1 => 'FII_BUDGET_FORECAST_C.adjust_ver_date()',
6419: t2 => 'VARIABLE',
6420: v2 => 'LENGTH(l_fc_sqlstmt)',
6421: t3 => 'VALUE',
6422: v3 => TO_CHAR(LENGTH(l_fc_sqlstmt)));

Line 6475: FII_MESSAGE.Func_Succ('FII_BUDGET_FORECAST_C.adjust_ver_date');

6471:
6472: FND_CONCURRENT.Af_Commit;
6473:
6474: IF (FIIBUUP_DEBUG) THEN
6475: FII_MESSAGE.Func_Succ('FII_BUDGET_FORECAST_C.adjust_ver_date');
6476: END IF;
6477: RETURN TRUE;
6478:
6479: EXCEPTION

Line 6487: v1 => 'FII_BUDGET_FORECAST_C.adjust_ver_date()');

6483: FII_MESSAGE.Write_Log
6484: (msg_name => 'FII_ERR_ENC_ROUT',
6485: token_num => 1,
6486: t1 => 'ROUTINE_NAME',
6487: v1 => 'FII_BUDGET_FORECAST_C.adjust_ver_date()');
6488:
6489: FII_MESSAGE.Func_Fail
6490: (func_name => 'FII_BUDGET_FORECAST_C.adjust_ver_date');
6491:

Line 6490: (func_name => 'FII_BUDGET_FORECAST_C.adjust_ver_date');

6486: t1 => 'ROUTINE_NAME',
6487: v1 => 'FII_BUDGET_FORECAST_C.adjust_ver_date()');
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;

Line 6503: v1 =>'FII_BUDGET_FORECAST_C.adjust_ver_date',

6499: -- SQL error occurs. Print out the error
6500: FII_MESSAGE.Write_Log(msg_name => 'FII_ERROR',
6501: token_num => 2,
6502: t1 => 'FUNCTION',
6503: v1 =>'FII_BUDGET_FORECAST_C.adjust_ver_date',
6504: t2 => 'SQLERRMC',
6505: v2 => SQLERRM);
6506:
6507: FII_MESSAGE.Func_Fail

Line 6508: (func_name => 'FII_BUDGET_FORECAST_C.adjust_ver_date');

6504: t2 => 'SQLERRMC',
6505: v2 => SQLERRM);
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;

Line 6538: -- result := FII_BUDGET_FORECAST_C.Main;

6534: -- X_Date : Purge date
6535: -- X_Time_Period : Purge period (Other than date)
6536: -- X_Debug : Debug mode indicator
6537: -- Example
6538: -- result := FII_BUDGET_FORECAST_C.Main;
6539: -- Notes
6540: --
6541: PROCEDURE Main(X_Mode VARCHAR2,
6542: X_Plan_Type VARCHAR2,

Line 6585: FII_MESSAGE.Func_Ent('FII_BUDGET_FORECAST_C.Main');

6581: l_drop_bud_data := 'N';
6582: l_drop_fc_data := 'N';
6583:
6584: IF FND_PROFILE.value('FII_DEBUG_MODE') = 'Y' THEN
6585: FII_MESSAGE.Func_Ent('FII_BUDGET_FORECAST_C.Main');
6586: END IF;
6587:
6588: -- Determine if process will be run in debug mode
6589: IF (NVL(X_Debug, 'N') <> 'N') THEN

Line 6617: v1 => 'FII_BUDGET_FORECAST_C.Main()',

6613: FII_MESSAGE.Write_Log
6614: (msg_name => 'FII_ROUTINE_VAL',
6615: token_num => 3 ,
6616: t1 => 'ROUTINE',
6617: v1 => 'FII_BUDGET_FORECAST_C.Main()',
6618: t2 => 'VARIABLE',
6619: v2 => 'Industry',
6620: t3 => 'VALUE',
6621: v3 => l_industry_profile);

Line 6644: v1 => 'FII_BUDGET_FORECAST_C.Main()',

6640: FII_MESSAGE.Write_Log
6641: (msg_name => 'FII_ROUTINE_VAL',
6642: token_num => 3 ,
6643: t1 => 'ROUTINE',
6644: v1 => 'FII_BUDGET_FORECAST_C.Main()',
6645: t2 => 'VARIABLE',
6646: v2 => 'FII: Budget Data from GL Balances',
6647: t3 => 'VALUE',
6648: v3 => l_psi_bud_from_bal);

Line 6674: FII_MESSAGE.Func_Succ(func_name => 'FII_BUDGET_FORECAST_C.Main');

6670: RETURN;
6671: ELSE
6672: -- GL Budget Extraction program completes successfully.
6673: IF (FIIBUUP_DEBUG) THEN
6674: FII_MESSAGE.Func_Succ(func_name => 'FII_BUDGET_FORECAST_C.Main');
6675: END IF;
6676:
6677: l_ret_status := FND_CONCURRENT.Set_Completion_Status
6678: (status => 'COMPLETE', message => NULL);

Line 6694: v1 => 'FII_BUDGET_FORECAST_C.Main()',

6690: FII_MESSAGE.Write_Log
6691: (msg_name => 'FII_ROUTINE_VAL',
6692: token_num => 3 ,
6693: t1 => 'ROUTINE',
6694: v1 => 'FII_BUDGET_FORECAST_C.Main()',
6695: t2 => 'VARIABLE',
6696: v2 => 'Budget Source',
6697: t3 => 'VALUE',
6698: v3 => l_budget_source);

Line 6717: FII_MESSAGE.Func_Succ(func_name => 'FII_BUDGET_FORECAST_C.Main');

6713: RETURN;
6714: ELSE
6715: -- GL Budget Extraction program completes successfully.
6716: IF (FIIBUUP_DEBUG) THEN
6717: FII_MESSAGE.Func_Succ(func_name => 'FII_BUDGET_FORECAST_C.Main');
6718: END IF;
6719:
6720: l_ret_status := FND_CONCURRENT.Set_Completion_Status
6721: (status => 'COMPLETE', message => NULL);

Line 6862: v1 => 'FII_BUDGET_FORECAST_C.Main()',

6858: FII_MESSAGE.Write_Log
6859: (msg_name => 'FII_ROUTINE_VAL',
6860: token_num => 3 ,
6861: t1 => 'ROUTINE',
6862: v1 => 'FII_BUDGET_FORECAST_C.Main()',
6863: t2 => 'VARIABLE',
6864: v2 => 'Operation Mode',
6865: t3 => 'VALUE',
6866: v3 => X_Mode);

Line 6872: v1 => 'FII_BUDGET_FORECAST_C.Main()',

6868: FII_MESSAGE.Write_Log
6869: (msg_name => 'FII_ROUTINE_VAL',
6870: token_num => 3 ,
6871: t1 => 'ROUTINE',
6872: v1 => 'FII_BUDGET_FORECAST_C.Main()',
6873: t2 => 'VARIABLE',
6874: v2 => 'Plan Type',
6875: t3 => 'VALUE',
6876: v3 => NVL(FIIBUUP_PURGE_PLAN_TYPE, 'N/A'));

Line 6882: v1 => 'FII_BUDGET_FORECAST_C.Main()',

6878: FII_MESSAGE.Write_Log
6879: (msg_name => 'FII_ROUTINE_VAL',
6880: token_num => 3 ,
6881: t1 => 'ROUTINE',
6882: v1 => 'FII_BUDGET_FORECAST_C.Main()',
6883: t2 => 'VARIABLE',
6884: v2 => 'Purge Time Unit',
6885: t3 => 'VALUE',
6886: v3 => NVL(FIIBUUP_PURGE_TIME_UNIT, 'N/A'));

Line 6892: v1 => 'FII_BUDGET_FORECAST_C.Main()',

6888: FII_MESSAGE.Write_Log
6889: (msg_name => 'FII_ROUTINE_VAL',
6890: token_num => 3 ,
6891: t1 => 'ROUTINE',
6892: v1 => 'FII_BUDGET_FORECAST_C.Main()',
6893: t2 => 'VARIABLE',
6894: v2 => 'Purge Date',
6895: t3 => 'VALUE',
6896: v3 => NVL(TO_CHAR(FIIBUUP_PURGE_DATE, 'YYYY/MM/DD HH24:MI:SS'), 'N/A'));

Line 6902: v1 => 'FII_BUDGET_FORECAST_C.Main()',

6898: FII_MESSAGE.Write_Log
6899: (msg_name => 'FII_ROUTINE_VAL',
6900: token_num => 3 ,
6901: t1 => 'ROUTINE',
6902: v1 => 'FII_BUDGET_FORECAST_C.Main()',
6903: t2 => 'VARIABLE',
6904: v2 => 'Purge Period',
6905: t3 => 'VALUE',
6906: v3 => NVL(FIIBUUP_PURGE_TIME_PERIOD, 'N/A'));

Line 6912: v1 => 'FII_BUDGET_FORECAST_C.Main()',

6908: FII_MESSAGE.Write_Log
6909: (msg_name => 'FII_ROUTINE_VAL',
6910: token_num => 3 ,
6911: t1 => 'ROUTINE',
6912: v1 => 'FII_BUDGET_FORECAST_C.Main()',
6913: t2 => 'VARIABLE',
6914: v2 => 'Purge Effective Date',
6915: t3 => 'VALUE',
6916: v3 => NVL(TO_CHAR(FIIBUUP_PURGE_EFF_DATE, 'YYYY/MM/DD HH24:MI:SS'), 'N/A'));

Line 6922: v1 => 'FII_BUDGET_FORECAST_C.Main()',

6918: FII_MESSAGE.Write_Log
6919: (msg_name => 'FII_ROUTINE_VAL',
6920: token_num => 3 ,
6921: t1 => 'ROUTINE',
6922: v1 => 'FII_BUDGET_FORECAST_C.Main()',
6923: t2 => 'VARIABLE',
6924: v2 => 'Debug Mode',
6925: t3 => 'VALUE',
6926: v3 => NVL(X_Debug, 'N'));

Line 6932: v1 => 'FII_BUDGET_FORECAST_C.Main()',

6928: FII_MESSAGE.Write_Log
6929: (msg_name => 'FII_ROUTINE_VAL',
6930: token_num => 3 ,
6931: t1 => 'ROUTINE',
6932: v1 => 'FII_BUDGET_FORECAST_C.Main()',
6933: t2 => 'VARIABLE',
6934: v2 => 'Primary Global Currency',
6935: t3 => 'VALUE',
6936: v3 => NVL(FIIBUUP_PRIM_CURR_CODE, 'NULL'));

Line 6942: v1 => 'FII_BUDGET_FORECAST_C.Main()',

6938: FII_MESSAGE.Write_Log
6939: (msg_name => 'FII_ROUTINE_VAL',
6940: token_num => 3 ,
6941: t1 => 'ROUTINE',
6942: v1 => 'FII_BUDGET_FORECAST_C.Main()',
6943: t2 => 'VARIABLE',
6944: v2 => 'Secondary Global Currency',
6945: t3 => 'VALUE',
6946: v3 => NVL(FIIBUUP_SEC_CURR_CODE, 'NULL'));

Line 6952: v1 => 'FII_BUDGET_FORECAST_C.Main()',

6948: FII_MESSAGE.Write_Log
6949: (msg_name => 'FII_ROUTINE_VAL',
6950: token_num => 3 ,
6951: t1 => 'ROUTINE',
6952: v1 => 'FII_BUDGET_FORECAST_C.Main()',
6953: t2 => 'VARIABLE',
6954: v2 => 'Budget Time Unit',
6955: t3 => 'VALUE',
6956: v3 => FIIBUUP_BUDGET_TIME_UNIT);

Line 6962: v1 => 'FII_BUDGET_FORECAST_C.Main()',

6958: FII_MESSAGE.Write_Log
6959: (msg_name => 'FII_ROUTINE_VAL',
6960: token_num => 3 ,
6961: t1 => 'ROUTINE',
6962: v1 => 'FII_BUDGET_FORECAST_C.Main()',
6963: t2 => 'VARIABLE',
6964: v2 => 'Forecast Time Unit',
6965: t3 => 'VALUE',
6966: v3 => FIIBUUP_FORECAST_TIME_UNIT);

Line 6995: FII_BUDGET_FORECAST_C.Psi_Budget_Extract(l_ret_code);

6991: IF (X_Mode = 'U' AND l_industry_profile = 'G') THEN
6992: -- Call the PSI Budget Extraction routine since this is a
6993: -- government install
6994:
6995: FII_BUDGET_FORECAST_C.Psi_Budget_Extract(l_ret_code);
6996:
6997: -- Bug 4674640: Added gather stats for the budget base table
6998: FND_STATS.gather_table_stats
6999: (ownname => l_fii_schema,

Line 7017: FII_MESSAGE.Func_Succ(func_name => 'FII_BUDGET_FORECAST_C.Main');

7013: RETURN;
7014:
7015: ELSE
7016: IF (FIIBUUP_DEBUG) THEN
7017: FII_MESSAGE.Func_Succ(func_name => 'FII_BUDGET_FORECAST_C.Main');
7018: END IF;
7019:
7020: l_ret_status := FND_CONCURRENT.Set_Completion_Status
7021: (status => 'COMPLETE', message => NULL);

Line 7067: v1 => 'FII_BUDGET_FORECAST_C.Main()',

7063: FII_MESSAGE.Write_Log
7064: (msg_name => 'FII_ROUTINE_VAL',
7065: token_num => 3 ,
7066: t1 => 'ROUTINE',
7067: v1 => 'FII_BUDGET_FORECAST_C.Main()',
7068: t2 => 'VARIABLE',
7069: v2 => 'l_prev_bud_time_unit',
7070: t3 => 'VALUE',
7071: v3 => l_prev_bud_time_unit);

Line 7077: v1 => 'FII_BUDGET_FORECAST_C.Main()',

7073: FII_MESSAGE.Write_Log
7074: (msg_name => 'FII_ROUTINE_VAL',
7075: token_num => 3 ,
7076: t1 => 'ROUTINE',
7077: v1 => 'FII_BUDGET_FORECAST_C.Main()',
7078: t2 => 'VARIABLE',
7079: v2 => 'l_prev_fc_time_unit',
7080: t3 => 'VALUE',
7081: v3 => l_prev_fc_time_unit);

Line 7338: FII_MESSAGE.Func_Succ(func_name => 'FII_BUDGET_FORECAST_C.Main');

7334: END;
7335:
7336: IF (l_int_count = 0) THEN
7337: IF (FIIBUUP_DEBUG) THEN
7338: FII_MESSAGE.Func_Succ(func_name => 'FII_BUDGET_FORECAST_C.Main');
7339: END IF;
7340:
7341: l_ret_status := FND_CONCURRENT.Set_Completion_Status
7342: (status => 'COMPLETE', message => NULL);

Line 7365: FII_BUDGET_FORECAST_C.Validate(l_ret_code);

7361: EXECUTE IMMEDIATE
7362: 'Lock Table FII_BUDGET_INTERFACE in exclusive mode nowait';
7363:
7364: -- Start upload process
7365: FII_BUDGET_FORECAST_C.Validate(l_ret_code);
7366:
7367: -- If Validate() ends with error or warning, we should stop here.
7368: IF (l_ret_code = 'E') THEN
7369: -- Validate has failed.

Line 7375: FII_MESSAGE.Func_Succ(func_name => 'FII_BUDGET_FORECAST_C.Main');

7371:
7372: ELSIF (l_ret_code = 'W') THEN
7373: -- Validate ends with warnings.
7374: IF (FIIBUUP_DEBUG) THEN
7375: FII_MESSAGE.Func_Succ(func_name => 'FII_BUDGET_FORECAST_C.Main');
7376: END IF;
7377:
7378: l_ret_status := FND_CONCURRENT.Set_Completion_Status
7379: (status => 'WARNING', message => NULL);

Line 7425: IF(NOT FII_BUDGET_FORECAST_C.Prior_version) THEN

7421: FETCH null_ver_date INTO l_null_ver_date_flag;
7422: CLOSE null_ver_date;
7423:
7424: IF (l_null_ver_date_flag = 'Y') THEN
7425: IF(NOT FII_BUDGET_FORECAST_C.Prior_version) THEN
7426: raise FIIBUUP_fatal_err;
7427: END IF;
7428:
7429: IF(NOT FII_BUDGET_FORECAST_C.Stage(NULL)) THEN

Line 7429: IF(NOT FII_BUDGET_FORECAST_C.Stage(NULL)) THEN

7425: IF(NOT FII_BUDGET_FORECAST_C.Prior_version) THEN
7426: raise FIIBUUP_fatal_err;
7427: END IF;
7428:
7429: IF(NOT FII_BUDGET_FORECAST_C.Stage(NULL)) THEN
7430: raise FIIBUUP_fatal_err;
7431: END IF;
7432:
7433: IF(NOT FII_BUDGET_FORECAST_C.Adjust_Amount) THEN

Line 7433: IF(NOT FII_BUDGET_FORECAST_C.Adjust_Amount) THEN

7429: IF(NOT FII_BUDGET_FORECAST_C.Stage(NULL)) THEN
7430: raise FIIBUUP_fatal_err;
7431: END IF;
7432:
7433: IF(NOT FII_BUDGET_FORECAST_C.Adjust_Amount) THEN
7434: raise FIIBUUP_fatal_err;
7435: END IF;
7436:
7437: IF(NOT FII_BUDGET_FORECAST_C.rollup_Stage) THEN

Line 7437: IF(NOT FII_BUDGET_FORECAST_C.rollup_Stage) THEN

7433: IF(NOT FII_BUDGET_FORECAST_C.Adjust_Amount) THEN
7434: raise FIIBUUP_fatal_err;
7435: END IF;
7436:
7437: IF(NOT FII_BUDGET_FORECAST_C.rollup_Stage) THEN
7438: raise FIIBUUP_fatal_err;
7439: END IF;
7440:
7441: IF(NOT FII_BUDGET_FORECAST_C.adjust_Stage) THEN

Line 7441: IF(NOT FII_BUDGET_FORECAST_C.adjust_Stage) THEN

7437: IF(NOT FII_BUDGET_FORECAST_C.rollup_Stage) THEN
7438: raise FIIBUUP_fatal_err;
7439: END IF;
7440:
7441: IF(NOT FII_BUDGET_FORECAST_C.adjust_Stage) THEN
7442: raise FIIBUUP_fatal_err;
7443: END IF;
7444:
7445: IF(NOT FII_BUDGET_FORECAST_C.merge) THEN

Line 7445: IF(NOT FII_BUDGET_FORECAST_C.merge) THEN

7441: IF(NOT FII_BUDGET_FORECAST_C.adjust_Stage) THEN
7442: raise FIIBUUP_fatal_err;
7443: END IF;
7444:
7445: IF(NOT FII_BUDGET_FORECAST_C.merge) THEN
7446: raise FIIBUUP_fatal_err;
7447: END IF;
7448:
7449: IF(NOT FII_BUDGET_FORECAST_C.adjust_ver_date) THEN

Line 7449: IF(NOT FII_BUDGET_FORECAST_C.adjust_ver_date) THEN

7445: IF(NOT FII_BUDGET_FORECAST_C.merge) THEN
7446: raise FIIBUUP_fatal_err;
7447: END IF;
7448:
7449: IF(NOT FII_BUDGET_FORECAST_C.adjust_ver_date) THEN
7450: raise FIIBUUP_fatal_err;
7451: END IF;
7452:
7453: END IF;

Line 7500: IF(NOT FII_BUDGET_FORECAST_C.Prior_version(l_version_date)) THEN

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;
7503:
7504: IF(NOT FII_BUDGET_FORECAST_C.Stage(l_version_date)) THEN

Line 7504: IF(NOT FII_BUDGET_FORECAST_C.Stage(l_version_date)) THEN

7500: IF(NOT FII_BUDGET_FORECAST_C.Prior_version(l_version_date)) THEN
7501: raise FIIBUUP_fatal_err;
7502: END IF;
7503:
7504: IF(NOT FII_BUDGET_FORECAST_C.Stage(l_version_date)) THEN
7505: raise FIIBUUP_fatal_err;
7506: END IF;
7507:
7508: IF(NOT FII_BUDGET_FORECAST_C.Adjust_Amount) THEN

Line 7508: IF(NOT FII_BUDGET_FORECAST_C.Adjust_Amount) THEN

7504: IF(NOT FII_BUDGET_FORECAST_C.Stage(l_version_date)) THEN
7505: raise FIIBUUP_fatal_err;
7506: END IF;
7507:
7508: IF(NOT FII_BUDGET_FORECAST_C.Adjust_Amount) THEN
7509: raise FIIBUUP_fatal_err;
7510: END IF;
7511:
7512: IF(NOT FII_BUDGET_FORECAST_C.Rollup_Stage) THEN

Line 7512: IF(NOT FII_BUDGET_FORECAST_C.Rollup_Stage) THEN

7508: IF(NOT FII_BUDGET_FORECAST_C.Adjust_Amount) THEN
7509: raise FIIBUUP_fatal_err;
7510: END IF;
7511:
7512: IF(NOT FII_BUDGET_FORECAST_C.Rollup_Stage) THEN
7513: raise FIIBUUP_fatal_err;
7514: END IF;
7515:
7516: IF(NOT FII_BUDGET_FORECAST_C.Adjust_Stage) THEN

Line 7516: IF(NOT FII_BUDGET_FORECAST_C.Adjust_Stage) THEN

7512: IF(NOT FII_BUDGET_FORECAST_C.Rollup_Stage) THEN
7513: raise FIIBUUP_fatal_err;
7514: END IF;
7515:
7516: IF(NOT FII_BUDGET_FORECAST_C.Adjust_Stage) THEN
7517: raise FIIBUUP_fatal_err;
7518: END IF;
7519:
7520: IF(NOT FII_BUDGET_FORECAST_C.merge) THEN

Line 7520: IF(NOT FII_BUDGET_FORECAST_C.merge) THEN

7516: IF(NOT FII_BUDGET_FORECAST_C.Adjust_Stage) THEN
7517: raise FIIBUUP_fatal_err;
7518: END IF;
7519:
7520: IF(NOT FII_BUDGET_FORECAST_C.merge) THEN
7521: raise FIIBUUP_fatal_err;
7522: END IF;
7523:
7524: IF(NOT FII_BUDGET_FORECAST_C.adjust_ver_date) THEN

Line 7524: IF(NOT FII_BUDGET_FORECAST_C.adjust_ver_date) THEN

7520: IF(NOT FII_BUDGET_FORECAST_C.merge) THEN
7521: raise FIIBUUP_fatal_err;
7522: END IF;
7523:
7524: IF(NOT FII_BUDGET_FORECAST_C.adjust_ver_date) THEN
7525: raise FIIBUUP_fatal_err;
7526: END IF;
7527:
7528: END LOOP;

Line 7533: IF(NOT FII_BUDGET_FORECAST_C.purge_eff_date(FIIBUUP_PURGE_EFF_DATE)) THEN

7529: CLOSE ver_date_cur;
7530:
7531: ELSIF (X_Mode = 'P') THEN
7532: IF (FIIBUUP_PURGE_EFF_DATE IS NOT NULL) THEN
7533: IF(NOT FII_BUDGET_FORECAST_C.purge_eff_date(FIIBUUP_PURGE_EFF_DATE)) THEN
7534: raise FIIBUUP_fatal_err;
7535: END IF;
7536:
7537: ELSE

Line 7576: FII_MESSAGE.Func_Succ(func_name => 'FII_BUDGET_FORECAST_C.Main');

7572:
7573: execute immediate 'alter session enable parallel dml';
7574:
7575: IF (FIIBUUP_DEBUG) THEN
7576: FII_MESSAGE.Func_Succ(func_name => 'FII_BUDGET_FORECAST_C.Main');
7577: END IF;
7578:
7579: l_ret_status := FND_CONCURRENT.Set_Completion_Status
7580: (status => 'COMPLETE', message => NULL);

Line 7591: v1 => 'FII_BUDGET_FORECAST_C.Main()');

7587: FII_MESSAGE.Write_Log
7588: (msg_name => 'FII_ERR_ENC_ROUT',
7589: token_num => 1,
7590: t1 => 'ROUTINE_NAME',
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 ||

Line 7593: FII_MESSAGE.Func_Fail(func_name => 'FII_BUDGET_FORECAST_C.Main');

7589: token_num => 1,
7590: t1 => 'ROUTINE_NAME',
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:

Line 7608: v1 => 'FII_BUDGET_FORECAST_C.Main()',

7604:
7605: FII_MESSAGE.Write_Log(msg_name => 'FII_ERROR',
7606: token_num => 2,
7607: t1 => 'FUNCTION',
7608: v1 => 'FII_BUDGET_FORECAST_C.Main()',
7609: t2 => 'SQLERRMC',
7610: v2 => SQLERRM);
7611:
7612: FII_MESSAGE.Func_Fail(func_name => 'FII_BUDGET_FORECAST_C.Main');

Line 7612: FII_MESSAGE.Func_Fail(func_name => 'FII_BUDGET_FORECAST_C.Main');

7608: v1 => 'FII_BUDGET_FORECAST_C.Main()',
7609: t2 => 'SQLERRMC',
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:

Line 7634: -- result := FII_BUDGET_FORECAST_C.Upload(errbuf, retcode);

7630: -- 05-03-02 S Kung Created
7631: -- Arguments
7632: -- X_Debug: Debug Mode indicator
7633: -- Example
7634: -- result := FII_BUDGET_FORECAST_C.Upload(errbuf, retcode);
7635: -- Notes
7636: --
7637: PROCEDURE Upload(errbuf OUT NOCOPY VARCHAR2,
7638: retcode OUT NOCOPY VARCHAR2,

Line 7641: FII_BUDGET_FORECAST_C.Main(X_Mode => 'U',

7637: PROCEDURE Upload(errbuf OUT NOCOPY VARCHAR2,
7638: retcode OUT NOCOPY VARCHAR2,
7639: X_Debug VARCHAR2) IS
7640: BEGIN
7641: FII_BUDGET_FORECAST_C.Main(X_Mode => 'U',
7642: X_Debug => X_Debug);
7643:
7644: EXCEPTION
7645: WHEN OTHERS THEN

Line 7671: -- result := FII_BUDGET_FORECAST_C.Purge

7667: -- X_Time_Period : Purge period (other than date)
7668: -- X_Purge_Eff_Date : Purge effective date
7669: -- X_Debug : Debug mode indicator
7670: -- Example
7671: -- result := FII_BUDGET_FORECAST_C.Purge
7672: -- (errbuf, retcode, 'B', 'P', 'Jan-01');
7673: --
7674: PROCEDURE Purge(errbuf OUT NOCOPY VARCHAR2,
7675: retcode OUT NOCOPY VARCHAR2,

Line 7684: FII_BUDGET_FORECAST_C.Main(X_Mode => 'P',

7680: X_Purge_Eff_Date VARCHAR2,
7681: X_Debug VARCHAR2) IS
7682: BEGIN
7683:
7684: FII_BUDGET_FORECAST_C.Main(X_Mode => 'P',
7685: X_Plan_Type => X_Plan_Type,
7686: X_Time_Unit => X_Time_Unit,
7687: X_Purge_Date => X_Purge_Date,
7688: X_Purge_Time_Period => X_Purge_Time_Period,

Line 7701: END FII_BUDGET_FORECAST_C;

7697: END Purge;
7698:
7699: -------------------------------------------------------------------------------
7700:
7701: END FII_BUDGET_FORECAST_C;