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.GL_FLATTEN_ACCESS_SETS dependencies on GL_MESSAGE

Line 19: GL_MESSAGE.Func_Ent

15: -- There is no need to clean up data before processing since
16: -- changes to GL_ACCESS_SET_ASSIGNMENTS will not be committed
17: -- until everything is done.
18:
19: GL_MESSAGE.Func_Ent
20: (func_name => 'GL_FLATTEN_ACCESS_SETS.Fix_Explicit_Sets');
21:
22: -- Call Fix_Flattened_Table to maintain GL_ACCESS_SET_ASSIGNMENTS.
23: ret_val := GL_FLATTEN_ACCESS_SETS.Fix_Flattened_Table;

Line 29: GL_MESSAGE.Func_Succ

25: IF (NOT ret_val) THEN
26: RAISE GLSTFL_fatal_err;
27: END IF;
28:
29: GL_MESSAGE.Func_Succ
30: (func_name => 'GL_FLATTEN_ACCESS_SETS.Fix_Explicit_Sets');
31:
32: RETURN TRUE;
33:

Line 38: GL_MESSAGE.Write_Log

34: -- Exception handling
35: EXCEPTION
36: WHEN GLSTFL_fatal_err THEN
37:
38: GL_MESSAGE.Write_Log
39: (msg_name => 'FLAT0002',
40: token_num => 1,
41: t1 => 'ROUTINE_NAME',
42: v1 => 'GL_FLATTEN_ACCESS_SETS.Fix_Explicit_Sets()');

Line 44: GL_MESSAGE.Func_Fail

40: token_num => 1,
41: t1 => 'ROUTINE_NAME',
42: v1 => 'GL_FLATTEN_ACCESS_SETS.Fix_Explicit_Sets()');
43:
44: GL_MESSAGE.Func_Fail
45: (func_name =>'GL_FLATTEN_ACCESS_SETS.Fix_Explicit_Sets');
46:
47: RETURN FALSE;
48:

Line 50: GL_MESSAGE.Write_Log

46:
47: RETURN FALSE;
48:
49: WHEN OTHERS THEN
50: GL_MESSAGE.Write_Log
51: (msg_name => 'SHRD0203',
52: token_num => 2,
53: t1 => 'FUNCTION',
54: v1 => 'GL_FLATTEN_ACCESS_SETS.Fix_Explicit_Sets()',

Line 58: GL_MESSAGE.Func_Fail

54: v1 => 'GL_FLATTEN_ACCESS_SETS.Fix_Explicit_Sets()',
55: t2 => 'SQLERRMC',
56: v2 => SQLERRM);
57:
58: GL_MESSAGE.Func_Fail
59: (func_name => 'GL_FLATTEN_ACCESS_SETS.Fix_Explicit_Sets');
60:
61: RETURN FALSE;
62:

Line 86: GL_MESSAGE.Func_Ent

82: -- 2) Call routine Fix_Norm_Table to maintain GL_ACCESS_SET_NORM_ASSIGN.
83: -- 3) Call routine Fix_Flattened_Table to maintain
84: -- GL_ACCESS_SET_ASSIGNMENTS.
85:
86: GL_MESSAGE.Func_Ent
87: (func_name => 'GL_FLATTEN_ACCESS_SETS.Fix_Implicit_Sets');
88:
89: -- Clean up GL_ACCESS_SET_NORM_ASSIGN
90: -- for any unprocessed data left over from previous failed run

Line 93: GL_MESSAGE.Write_Log

89: -- Clean up GL_ACCESS_SET_NORM_ASSIGN
90: -- for any unprocessed data left over from previous failed run
91:
92: IF (GL_FLATTEN_SETUP_DATA.GLSTFL_Debug) THEN
93: GL_MESSAGE.Write_Log
94: (msg_name => 'SHRD0180',
95: token_num => 2,
96: t1 => 'ROUTINE',
97: v1 => 'Fix_Implicit_Sets()',

Line 113: GL_MESSAGE.Write_Log(msg_name => 'SHRD0119',

109: GL_FLATTEN_SETUP_DATA.GLSTFL_COA_ID
110: AND automatically_created_flag = 'Y');
111:
112: row_count := SQL%ROWCOUNT;
113: GL_MESSAGE.Write_Log(msg_name => 'SHRD0119',
114: token_num => 2,
115: t1 => 'NUM',
116: v1 => TO_CHAR(row_count),
117: t2 => 'TABLE',

Line 122: GL_MESSAGE.Write_Log

118: v2 => 'GL_ACCESS_SET_NORM_ASSIGN');
119: row_count := 0;
120:
121: IF (GL_FLATTEN_SETUP_DATA.GLSTFL_Debug) THEN
122: GL_MESSAGE.Write_Log
123: (msg_name => 'SHRD0180',
124: token_num => 2,
125: t1 => 'ROUTINE',
126: v1 => 'Fix_Implicit_Sets()',

Line 143: GL_MESSAGE.Write_Log(msg_name => 'SHRD0118',

139: GL_FLATTEN_SETUP_DATA.GLSTFL_COA_ID
140: AND automatically_created_flag = 'Y');
141:
142: row_count := SQL%ROWCOUNT;
143: GL_MESSAGE.Write_Log(msg_name => 'SHRD0118',
144: token_num => 2,
145: t1 => 'NUM',
146: v1 => TO_CHAR(row_count),
147: t2 => 'TABLE',

Line 169: GL_MESSAGE.Func_Succ

165: IF (NOT ret_val) THEN
166: RAISE GLSTFL_fatal_err;
167: END IF;
168:
169: GL_MESSAGE.Func_Succ
170: (func_name => 'GL_FLATTEN_ACCESS_SETS.Fix_Implicit_Sets');
171:
172: RETURN TRUE;
173:

Line 177: GL_MESSAGE.Write_Log

173:
174: EXCEPTION
175: WHEN GLSTFL_fatal_err THEN
176:
177: GL_MESSAGE.Write_Log
178: (msg_name => 'FLAT0002',
179: token_num => 1,
180: t1 => 'ROUTINE_NAME',
181: v1 => 'GL_FLATTEN_ACCESS_SETS.Fix_Implicit_Sets()');

Line 186: GL_MESSAGE.Func_Fail

182:
183: -- Rollback
184: FND_CONCURRENT.Af_Rollback;
185:
186: GL_MESSAGE.Func_Fail
187: (func_name =>'GL_FLATTEN_ACCESS_SETS.Fix_Implicit_Sets');
188:
189: RETURN FALSE;
190:

Line 192: GL_MESSAGE.Write_Log

188:
189: RETURN FALSE;
190:
191: WHEN OTHERS THEN
192: GL_MESSAGE.Write_Log
193: (msg_name => 'SHRD0203',
194: token_num => 2,
195: t1 => 'FUNCTION',
196: v1 => 'GL_FLATTEN_ACCESS_SETS.Fix_Implicit_Sets()',

Line 203: GL_MESSAGE.Func_Fail

199:
200: -- Rollback
201: FND_CONCURRENT.Af_Rollback;
202:
203: GL_MESSAGE.Func_Fail
204: (func_name => 'GL_FLATTEN_ACCESS_SETS.Fix_Implicit_Sets');
205:
206: RETURN FALSE;
207:

Line 244: GL_MESSAGE.Func_Ent

240: *** -- on new records in GL_LEDGER_HIERARCHIES. Several
241: *** -- statements will be run to process legal and management
242: *** -- hierarchies. */
243:
244: GL_MESSAGE.Func_Ent
245: (func_name => 'GL_FLATTEN_ACCESS_SETS.Fix_Norm_Table');
246:
247: IF (GL_FLATTEN_SETUP_DATA.GLSTFL_Debug) THEN
248: GL_MESSAGE.Write_Log

Line 248: GL_MESSAGE.Write_Log

244: GL_MESSAGE.Func_Ent
245: (func_name => 'GL_FLATTEN_ACCESS_SETS.Fix_Norm_Table');
246:
247: IF (GL_FLATTEN_SETUP_DATA.GLSTFL_Debug) THEN
248: GL_MESSAGE.Write_Log
249: (msg_name => 'SHRD0180',
250: token_num => 2,
251: t1 => 'ROUTINE',
252: v1 => 'Fix_Norm_Table()',

Line 299: GL_MESSAGE.Write_Log(msg_name => 'SHRD0117',

295: AND glasna.end_date is NULL
296: AND NVL(glasna.status_code, 'X') <> 'D'));
297:
298: row_count := SQL%ROWCOUNT;
299: GL_MESSAGE.Write_Log(msg_name => 'SHRD0117',
300: token_num => 2,
301: t1 => 'NUM',
302: v1 => TO_CHAR(row_count),
303: t2 => 'TABLE',

Line 311: GL_MESSAGE.Func_Succ

307: -- Commit all work
308: FND_CONCURRENT.Af_Commit;
309:
310:
311: GL_MESSAGE.Func_Succ
312: (func_name => 'GL_FLATTEN_ACCESS_SETS.Fix_Norm_Table');
313:
314: RETURN TRUE;
315:

Line 318: GL_MESSAGE.Write_Log

314: RETURN TRUE;
315:
316: EXCEPTION
317: WHEN OTHERS THEN
318: GL_MESSAGE.Write_Log
319: (msg_name => 'SHRD0203',
320: token_num => 2,
321: t1 => 'FUNCTION',
322: v1 => 'GL_FLATTEN_ACCESS_SETS.Fix_Norm_Table()',

Line 328: GL_MESSAGE.Func_Fail

324: v2 => SQLERRM);
325:
326: FND_CONCURRENT.Af_Rollback;
327:
328: GL_MESSAGE.Func_Fail
329: (func_name => 'GL_FLATTEN_ACCESS_SETS.Fix_Norm_Table');
330:
331: RETURN FALSE;
332:

Line 371: GL_MESSAGE.Func_Ent

367: -- ranges for a particular ledger/segment value assignment in
368: -- any management hierarchies.
369: -- If so, report as error and abort processing.
370:
371: GL_MESSAGE.Func_Ent
372: (func_name => 'GL_FLATTEN_ACCESS_SETS.Fix_Flattened_Table');
373:
374: -- For modes LH, LS, VS and AS, obtain shared lock on both balancing
375: -- and management segments.

Line 380: GL_MESSAGE.Write_Log

376: IF (GL_FLATTEN_SETUP_DATA.GLSTFL_OP_MODE IN
377: ('VH', 'LH', 'LS', 'AS', 'VS')) THEN
378:
379: IF (GL_FLATTEN_SETUP_DATA.GLSTFL_Debug) THEN
380: GL_MESSAGE.Write_Log
381: (msg_name => 'SHRD0180',
382: token_num => 2,
383: t1 => 'ROUTINE',
384: v1 => 'Fix_Flattened_Table()',

Line 412: GL_MESSAGE.Write_Log

408:
409: IF (GL_FLATTEN_SETUP_DATA.GLSTFL_BAL_VS_ID <>
410: GL_FLATTEN_SETUP_DATA.GLSTFL_MGT_VS_ID) THEN
411: IF (GL_FLATTEN_SETUP_DATA.GLSTFL_Debug) THEN
412: GL_MESSAGE.Write_Log
413: (msg_name => 'SHRD0180',
414: token_num => 2,
415: t1 => 'ROUTINE',
416: v1 => 'Fix_Flattened_Table()',

Line 446: GL_MESSAGE.Write_Log

442:
443: -- Delete records from GL_ACCESS_SET_ASSIGNMENTS based on
444: -- GL_ACCESS_SET_ASSIGN_INT
445: IF (GL_FLATTEN_SETUP_DATA.GLSTFL_Debug) THEN
446: GL_MESSAGE.Write_Log
447: (msg_name => 'SHRD0180',
448: token_num => 2,
449: t1 => 'ROUTINE',
450: v1 => 'Fix_Flattened_Table()',

Line 464: GL_MESSAGE.Write_Log(msg_name => 'SHRD0119',

460: FROM GL_ACCESS_SET_ASSIGN_INT glasai
461: WHERE glasai.status_code = 'D');
462:
463: row_count := SQL%ROWCOUNT;
464: GL_MESSAGE.Write_Log(msg_name => 'SHRD0119',
465: token_num => 2,
466: t1 => 'NUM',
467: v1 => TO_CHAR(row_count),
468: t2 => 'TABLE',

Line 494: GL_MESSAGE.Write_Log

490: WHEN NO_DATA_FOUND THEN
491: row_count := 0;
492: END;
493:
494: GL_MESSAGE.Write_Log
495: (msg_name => 'SHRD0180',
496: token_num => 2,
497: t1 => 'ROUTINE',
498: v1 => 'Fix_Flattened_Table()',

Line 508: GL_MESSAGE.Write_Log

504: END IF;
505:
506: -- Insert new records into GL_ACCESS_SET_ASSIGNMENTS
507: IF (GL_FLATTEN_SETUP_DATA.GLSTFL_Debug) THEN
508: GL_MESSAGE.Write_Log
509: (msg_name => 'SHRD0180',
510: token_num => 2,
511: t1 => 'ROUTINE',
512: v1 => 'Fix_Flattened_Table()',

Line 547: GL_MESSAGE.Write_Log(msg_name => 'SHRD0117',

543: NVL(glasai.end_date,
544: TO_DATE('12/31/9999', 'MM/DD/YYYY'))));
545:
546: row_count := SQL%ROWCOUNT;
547: GL_MESSAGE.Write_Log(msg_name => 'SHRD0117',
548: token_num => 2,
549: t1 => 'NUM',
550: v1 => TO_CHAR(row_count),
551: t2 => 'TABLE',

Line 560: GL_MESSAGE.Write_Log

556: -- Check if a particular ledger/segment value have overlapping effective
557: -- dates for management hierarchies
558: IF (GL_FLATTEN_SETUP_DATA.GLSTFL_OP_MODE in ('LH', 'SH', 'FF', 'VH')) THEN
559: IF (GL_FLATTEN_SETUP_DATA.GLSTFL_Debug) THEN
560: GL_MESSAGE.Write_Log
561: (msg_name => 'SHRD0180',
562: token_num => 2,
563: t1 => 'ROUTINE',
564: v1 => 'Fix_Flattened_Table()',

Line 617: GL_MESSAGE.Write_Log(msg_name => 'FLAT0016',

613:
614: IF (SQL%FOUND) THEN
615: -- Overlapping date ranges found, print out error message
616: -- and abort.
617: GL_MESSAGE.Write_Log(msg_name => 'FLAT0016',
618: token_num => 0);
619:
620: DECLARE
621: CURSOR overlap_dates_cursor IS

Line 665: GL_MESSAGE.Write_Log

661: FETCH overlap_dates_cursor INTO curr_as, curr_ldg, curr_seg_val;
662: EXIT WHEN overlap_dates_cursor%NOTFOUND;
663:
664: IF (curr_as IS NOT NULL) THEN
665: GL_MESSAGE.Write_Log
666: (msg_name => 'FLAT0003',
667: token_num => 3,
668: t1 => 'ACCESS_SET_NAME',
669: v1 => curr_as,

Line 692: GL_MESSAGE.Func_Succ

688: -- when all clean up work is completed. This is to make sure
689: -- that SH and FF processes cannot start until all status codes
690: -- are reset to current.
691:
692: GL_MESSAGE.Func_Succ
693: (func_name => 'GL_FLATTEN_ACCESS_SETS.Fix_Flattened_Table');
694:
695: RETURN TRUE;
696:

Line 700: GL_MESSAGE.Write_Log

696:
697: EXCEPTION
698: WHEN GLSTFL_fatal_err THEN
699:
700: GL_MESSAGE.Write_Log
701: (msg_name => 'FLAT0002',
702: token_num => 1,
703: t1 => 'ROUTINE_NAME',
704: v1 => 'GL_FLATTEN_ACCESS_SETS.Fix_Flattened_Table()');

Line 706: GL_MESSAGE.Func_Fail

702: token_num => 1,
703: t1 => 'ROUTINE_NAME',
704: v1 => 'GL_FLATTEN_ACCESS_SETS.Fix_Flattened_Table()');
705:
706: GL_MESSAGE.Func_Fail
707: (func_name => 'GL_FLATTEN_ACCESS_SETS.Fix_Flattened_Table');
708:
709: RETURN FALSE;
710:

Line 712: GL_MESSAGE.Write_Log

708:
709: RETURN FALSE;
710:
711: WHEN OTHERS THEN
712: GL_MESSAGE.Write_Log
713: (msg_name => 'SHRD0203',
714: token_num => 2,
715: t1 => 'FUNCTION',
716: v1 => 'GL_FLATTEN_ACCESS_SETS.Fix_Flattened_Table()',

Line 720: GL_MESSAGE.Func_Fail

716: v1 => 'GL_FLATTEN_ACCESS_SETS.Fix_Flattened_Table()',
717: t2 => 'SQLERRMC',
718: v2 => SQLERRM);
719:
720: GL_MESSAGE.Func_Fail
721: (func_name => 'GL_FLATTEN_ACCESS_SETS.Fix_Flattened_Table');
722:
723: RETURN FALSE;
724:

Line 748: GL_MESSAGE.Func_Ent

744: -- necessary here.
745: -- 2) If processing is needed, run statements to populate
746: -- GL_ACCESS_SET_ASSIGN_INT based on the mode of operation.
747:
748: GL_MESSAGE.Func_Ent
749: (func_name => 'GL_FLATTEN_ACCESS_SETS.Populate_Temp_Table');
750:
751: IF (GL_FLATTEN_SETUP_DATA.GLSTFL_Debug) THEN
752: GL_MESSAGE.Write_Log

Line 752: GL_MESSAGE.Write_Log

748: GL_MESSAGE.Func_Ent
749: (func_name => 'GL_FLATTEN_ACCESS_SETS.Populate_Temp_Table');
750:
751: IF (GL_FLATTEN_SETUP_DATA.GLSTFL_Debug) THEN
752: GL_MESSAGE.Write_Log
753: (msg_name => 'SHRD0180',
754: token_num => 2,
755: t1 => 'ROUTINE',
756: v1 => 'Populate_Temp_Table()',

Line 914: GL_MESSAGE.Write_Log

910:
911: IF (cont_processing) THEN
912:
913: IF (GL_FLATTEN_SETUP_DATA.GLSTFL_Debug) THEN
914: GL_MESSAGE.Write_Log
915: (msg_name => 'FLAT0017',
916: token_num => 1,
917: t1 => 'OP_MODE',
918: v1 => GL_FLATTEN_SETUP_DATA.GLSTFL_OP_MODE);

Line 935: GL_MESSAGE.Write_Log

931: -- mode FF.
932: IF (GL_FLATTEN_SETUP_DATA.GLSTFL_OP_MODE = 'SH') THEN
933:
934: IF (GL_FLATTEN_SETUP_DATA.GLSTFL_Debug) THEN
935: GL_MESSAGE.Write_Log
936: (msg_name => 'SHRD0180',
937: token_num => 2,
938: t1 => 'ROUTINE',
939: v1 => 'Populate_Temp_Table()',

Line 987: GL_MESSAGE.Write_Log(msg_name => 'SHRD0117',

983: --
984: -- Also, records in gllsa will never have a status_code of U.
985:
986: row_count := SQL%ROWCOUNT;
987: GL_MESSAGE.Write_Log(msg_name => 'SHRD0117',
988: token_num => 2,
989: t1 => 'NUM',
990: v1 => TO_CHAR(row_count),
991: t2 => 'TABLE',

Line 1003: GL_MESSAGE.Write_Log

999: -- to add in the new segment values to the assignments.
1000: IF (sh_ff_all_val_changed) THEN
1001:
1002: IF (GL_FLATTEN_SETUP_DATA.GLSTFL_Debug) THEN
1003: GL_MESSAGE.Write_Log
1004: (msg_name => 'SHRD0180',
1005: token_num => 2,
1006: t1 => 'ROUTINE',
1007: v1 => 'Populate_Temp_Table()',

Line 1044: GL_MESSAGE.Write_Log(msg_name => 'SHRD0117',

1040: AND gllsa.ledger_set_id(+) = glasna.ledger_id
1041: AND NVL(gllsa.status_code(+), 'X') <> 'I');
1042:
1043: row_count := SQL%ROWCOUNT;
1044: GL_MESSAGE.Write_Log(msg_name => 'SHRD0117',
1045: token_num => 2,
1046: t1 => 'NUM',
1047: v1 => TO_CHAR(row_count),
1048: t2 => 'TABLE',

Line 1059: GL_MESSAGE.Write_Log

1055:
1056: row_count := 0;
1057:
1058: IF (GL_FLATTEN_SETUP_DATA.GLSTFL_Debug) THEN
1059: GL_MESSAGE.Write_Log
1060: (msg_name => 'SHRD0180',
1061: token_num => 2,
1062: t1 => 'ROUTINE',
1063: v1 => 'Populate_Temp_Table()',

Line 1096: GL_MESSAGE.Write_Log(msg_name => 'SHRD0117',

1092:
1093:
1094:
1095: row_count := SQL%ROWCOUNT;
1096: GL_MESSAGE.Write_Log(msg_name => 'SHRD0117',
1097: token_num => 2,
1098: t1 => 'NUM',
1099: v1 => TO_CHAR(row_count),
1100: t2 => 'TABLE',

Line 1114: GL_MESSAGE.Write_Log

1110:
1111: row_count := 0;
1112:
1113: IF (GL_FLATTEN_SETUP_DATA.GLSTFL_Debug) THEN
1114: GL_MESSAGE.Write_Log
1115: (msg_name => 'SHRD0180',
1116: token_num => 2,
1117: t1 => 'ROUTINE',
1118: v1 => 'Populate_Temp_Table()',

Line 1159: GL_MESSAGE.Write_Log(msg_name => 'SHRD0117',

1155: OR ( glasna.segment_value_type_code = 'S'
1156: AND glasna.all_segment_value_flag = 'N')));
1157:
1158: row_count := SQL%ROWCOUNT;
1159: GL_MESSAGE.Write_Log(msg_name => 'SHRD0117',
1160: token_num => 2,
1161: t1 => 'NUM',
1162: v1 => TO_CHAR(row_count),
1163: t2 => 'TABLE',

Line 1168: GL_MESSAGE.Write_Log

1164: v2 => 'GL_ACCESS_SET_ASSIGN_INT');
1165: row_count := 0;
1166:
1167: IF (GL_FLATTEN_SETUP_DATA.GLSTFL_Debug) THEN
1168: GL_MESSAGE.Write_Log
1169: (msg_name => 'SHRD0180',
1170: token_num => 2,
1171: t1 => 'ROUTINE',
1172: v1 => 'Populate_Temp_Table()',

Line 1211: GL_MESSAGE.Write_Log(msg_name => 'SHRD0117',

1207: AND glsvh.parent_flex_value = 'T'
1208: AND NVL(glsvh.status_code, 'X') <> 'I');
1209:
1210: row_count := SQL%ROWCOUNT;
1211: GL_MESSAGE.Write_Log(msg_name => 'SHRD0117',
1212: token_num => 2,
1213: t1 => 'NUM',
1214: v1 => TO_CHAR(row_count),
1215: t2 => 'TABLE',

Line 1220: GL_MESSAGE.Write_Log

1216: v2 => 'GL_ACCESS_SET_ASSIGN_INT');
1217: row_count := 0;
1218:
1219: IF (GL_FLATTEN_SETUP_DATA.GLSTFL_Debug) THEN
1220: GL_MESSAGE.Write_Log
1221: (msg_name => 'SHRD0180',
1222: token_num => 2,
1223: t1 => 'ROUTINE',
1224: v1 => 'Populate_Temp_Table()',

Line 1264: GL_MESSAGE.Write_Log(msg_name => 'SHRD0117',

1260: AND glsvh.parent_flex_value = glasna.segment_value
1261: AND NVL(glsvh.status_code, 'X') <> 'I');
1262:
1263: row_count := SQL%ROWCOUNT;
1264: GL_MESSAGE.Write_Log(msg_name => 'SHRD0117',
1265: token_num => 2,
1266: t1 => 'NUM',
1267: v1 => TO_CHAR(row_count),
1268: t2 => 'TABLE',

Line 1273: GL_MESSAGE.Write_Log

1269: v2 => 'GL_ACCESS_SET_ASSIGN_INT');
1270: row_count := 0;
1271:
1272: IF (GL_FLATTEN_SETUP_DATA.GLSTFL_Debug) THEN
1273: GL_MESSAGE.Write_Log
1274: (msg_name => 'SHRD0180',
1275: token_num => 2,
1276: t1 => 'ROUTINE',
1277: v1 => 'Populate_Temp_Table()',

Line 1310: GL_MESSAGE.Write_Log(msg_name => 'SHRD0117',

1306: AND glasna.status_code = 'I'
1307: AND glasna.request_id = GL_FLATTEN_SETUP_DATA.GLSTFL_REQ_ID);
1308:
1309: row_count := SQL%ROWCOUNT;
1310: GL_MESSAGE.Write_Log(msg_name => 'SHRD0117',
1311: token_num => 2,
1312: t1 => 'NUM',
1313: v1 => TO_CHAR(row_count),
1314: t2 => 'TABLE',

Line 1329: GL_MESSAGE.Write_Log

1325:
1326: IF (as_single_val_changed) THEN
1327:
1328: IF (GL_FLATTEN_SETUP_DATA.GLSTFL_Debug) THEN
1329: GL_MESSAGE.Write_Log
1330: (msg_name => 'SHRD0180',
1331: token_num => 2,
1332: t1 => 'ROUTINE',
1333: v1 => 'Populate_Temp_Table()',

Line 1372: GL_MESSAGE.Write_Log(msg_name => 'SHRD0117',

1368: AND NVL(gllsa.status_code(+), 'X') <> 'I');
1369: -- gllsa never has U records
1370:
1371: row_count := SQL%ROWCOUNT;
1372: GL_MESSAGE.Write_Log(msg_name => 'SHRD0117',
1373: token_num => 2,
1374: t1 => 'NUM',
1375: v1 => TO_CHAR(row_count),
1376: t2 => 'TABLE',

Line 1384: GL_MESSAGE.Write_Log

1380:
1381: IF (as_all_val_changed) THEN
1382:
1383: IF (GL_FLATTEN_SETUP_DATA.GLSTFL_Debug) THEN
1384: GL_MESSAGE.Write_Log
1385: (msg_name => 'SHRD0180',
1386: token_num => 2,
1387: t1 => 'ROUTINE',
1388: v1 => 'Populate_Temp_Table()',

Line 1428: GL_MESSAGE.Write_Log(msg_name => 'SHRD0117',

1424: AND glsvh.parent_flex_value = 'T'
1425: AND NVL(glsvh.status_code, 'X') <> 'I');
1426:
1427: row_count := SQL%ROWCOUNT;
1428: GL_MESSAGE.Write_Log(msg_name => 'SHRD0117',
1429: token_num => 2,
1430: t1 => 'NUM',
1431: v1 => TO_CHAR(row_count),
1432: t2 => 'TABLE',

Line 1440: GL_MESSAGE.Write_Log

1436:
1437: IF (as_parent_val_changed) THEN
1438:
1439: IF (GL_FLATTEN_SETUP_DATA.GLSTFL_Debug) THEN
1440: GL_MESSAGE.Write_Log
1441: (msg_name => 'SHRD0180',
1442: token_num => 2,
1443: t1 => 'ROUTINE',
1444: v1 => 'Populate_Temp_Table()',

Line 1485: GL_MESSAGE.Write_Log(msg_name => 'SHRD0117',

1481: AND glsvh.parent_flex_value = glasna.segment_value
1482: AND NVL(glsvh.status_code, 'X') <> 'I');
1483:
1484: row_count := SQL%ROWCOUNT;
1485: GL_MESSAGE.Write_Log(msg_name => 'SHRD0117',
1486: token_num => 2,
1487: t1 => 'NUM',
1488: v1 => TO_CHAR(row_count),
1489: t2 => 'TABLE',

Line 1499: GL_MESSAGE.Write_Log

1495:
1496: ELSE
1497:
1498: IF (GL_FLATTEN_SETUP_DATA.GLSTFL_Debug) THEN
1499: GL_MESSAGE.Write_Log
1500: (msg_name => 'FLAT0017',
1501: token_num => 1,
1502: t1 => 'OP_MODE',
1503: v1 => GL_FLATTEN_SETUP_DATA.GLSTFL_OP_MODE);

Line 1511: GL_MESSAGE.Func_Succ

1507:
1508: -- Commit all work
1509: FND_CONCURRENT.Af_Commit;
1510:
1511: GL_MESSAGE.Func_Succ
1512: (func_name => 'GL_FLATTEN_ACCESS_SETS.Populate_Temp_Table');
1513:
1514: RETURN TRUE;
1515:

Line 1518: GL_MESSAGE.Write_Log

1514: RETURN TRUE;
1515:
1516: EXCEPTION
1517: WHEN OTHERS THEN
1518: GL_MESSAGE.Write_Log
1519: (msg_name => 'SHRD0203',
1520: token_num => 2,
1521: t1 => 'FUNCTION',
1522: v1 => 'GL_FLATTEN_ACCESS_SETS.Populate_Temp_Table()',

Line 1529: GL_MESSAGE.Func_Fail

1525:
1526: -- Rollback
1527: FND_CONCURRENT.Af_Rollback;
1528:
1529: GL_MESSAGE.Func_Fail
1530: (func_name => 'GL_FLATTEN_ACCESS_SETS.Populate_Temp_Table');
1531:
1532: RETURN FALSE;
1533:

Line 1581: GL_MESSAGE.Func_Ent

1577: -- 4) Disable records in GL_ACCESS_SET_ASSIGNMENTS if there exists an
1578: -- effective record in GL_ACCESS_SET_ASSIGN_INT that has a higher
1579: -- access privilege.
1580:
1581: GL_MESSAGE.Func_Ent
1582: (func_name => 'GL_FLATTEN_ACCESS_SETS.Enable_Record');
1583:
1584: -- Pick a record with access_privilege_code of B that has
1585: -- the smallest rowid, and disable all other records

Line 1596: GL_MESSAGE.Write_Log

1592: -- have records with a negative access_set_id. This is because
1593: -- for implicit access sets they should never have more than
1594: -- 1 record for each access set/ledger/segment value combination.
1595: IF (GL_FLATTEN_SETUP_DATA.GLSTFL_Debug) THEN
1596: GL_MESSAGE.Write_Log
1597: (msg_name => 'SHRD0180',
1598: token_num => 2,
1599: t1 => 'ROUTINE',
1600: v1 => 'Enable_Record()',

Line 1628: GL_MESSAGE.Write_Log(msg_name => 'SHRD0118',

1624: GROUP BY glasa2.access_set_id, glasa2.ledger_id,
1625: glasa2.segment_value);
1626:
1627: row_count := SQL%ROWCOUNT;
1628: GL_MESSAGE.Write_Log(msg_name => 'SHRD0118',
1629: token_num => 2,
1630: t1 => 'NUM',
1631: v1 => TO_CHAR(row_count),
1632: t2 => 'TABLE',

Line 1642: GL_MESSAGE.Write_Log

1638: -- This statement will only update records if the first
1639: -- statement does not enable any record, since otherwise
1640: -- it will never pass the outer join test.
1641: IF (GL_FLATTEN_SETUP_DATA.GLSTFL_Debug) THEN
1642: GL_MESSAGE.Write_Log
1643: (msg_name => 'SHRD0180',
1644: token_num => 2,
1645: t1 => 'ROUTINE',
1646: v1 => 'Enable_Record()',

Line 1674: GL_MESSAGE.Write_Log(msg_name => 'SHRD0118',

1670: GROUP BY glasa2.access_set_id, glasa2.ledger_id,
1671: glasa2.segment_value);
1672:
1673: row_count := SQL%ROWCOUNT;
1674: GL_MESSAGE.Write_Log(msg_name => 'SHRD0118',
1675: token_num => 2,
1676: t1 => 'NUM',
1677: v1 => TO_CHAR(row_count),
1678: t2 => 'TABLE',

Line 1686: GL_MESSAGE.Write_Log

1682: -- Check if there exists a record in GL_ACCESS_SET_ASSIGNMENTS
1683: -- that has a higher or equal access privilege. If so, disable the
1684: -- corresponding record(s) in GL_ACCESS_SET_ASSIGN_INT.
1685: IF (GL_FLATTEN_SETUP_DATA.GLSTFL_Debug) THEN
1686: GL_MESSAGE.Write_Log
1687: (msg_name => 'SHRD0180',
1688: token_num => 2,
1689: t1 => 'ROUTINE',
1690: v1 => 'Enable_Record()',

Line 1717: GL_MESSAGE.Write_Log(msg_name => 'SHRD0118',

1713: OR ( glasa.access_privilege_code = 'R'
1714: AND glasai2.access_privilege_code = 'R')));
1715:
1716: row_count := SQL%ROWCOUNT;
1717: GL_MESSAGE.Write_Log(msg_name => 'SHRD0118',
1718: token_num => 2,
1719: t1 => 'NUM',
1720: v1 => TO_CHAR(row_count),
1721: t2 => 'TABLE',

Line 1727: GL_MESSAGE.Write_Log

1723: row_count := 0;
1724:
1725:
1726: IF (GL_FLATTEN_SETUP_DATA.GLSTFL_Debug) THEN
1727: GL_MESSAGE.Write_Log
1728: (msg_name => 'SHRD0180',
1729: token_num => 2,
1730: t1 => 'ROUTINE',
1731: v1 => 'Enable_Record()',

Line 1758: GL_MESSAGE.Write_Log

1754: IF (curr_as_id IS NOT NULL) THEN
1755:
1756: /*
1757: IF (GL_FLATTEN_SETUP_DATA.GLSTFL_Debug) THEN
1758: GL_MESSAGE.Write_Log
1759: (msg_name => 'FLAT0020',
1760: token_num => 3,
1761: t1 => 'AS_ID',
1762: v1 => TO_CHAR(curr_as_id),

Line 1804: ** GL_MESSAGE.Write_Log

1800: END LOOP;
1801:
1802: /*
1803: ** IF (GL_FLATTEN_SETUP_DATA.GLSTFL_Debug) THEN
1804: ** GL_MESSAGE.Write_Log
1805: ** (msg_name => 'FLAT0020',
1806: ** token_num => 1,
1807: ** t1 => 'NUM',
1808: ** v1 => TO_CHAR(dup_access_assign_cursor%ROWCOUNT));

Line 1811: GL_MESSAGE.Write_Log(msg_name => 'SHRD0118',

1807: ** t1 => 'NUM',
1808: ** v1 => TO_CHAR(dup_access_assign_cursor%ROWCOUNT));
1809: ** END IF;
1810: */
1811: GL_MESSAGE.Write_Log(msg_name => 'SHRD0118',
1812: token_num => 2,
1813: t1 => 'NUM',
1814: v1 => TO_CHAR(row_count),
1815: t2 => 'TABLE',

Line 1829: GL_MESSAGE.Write_Log

1825: -- In this case, the record in GL_ACCESS_SET_ASSIGNMENTS will
1826: -- be disabled.
1827:
1828: IF (GL_FLATTEN_SETUP_DATA.GLSTFL_Debug) THEN
1829: GL_MESSAGE.Write_Log
1830: (msg_name => 'SHRD0180',
1831: token_num => 2,
1832: t1 => 'ROUTINE',
1833: v1 => 'Enable_Record()',

Line 1860: GL_MESSAGE.Write_Log(msg_name => 'SHRD0118',

1856: AND glas.access_set_id = glasai.access_set_id
1857: AND glas.automatically_created_flag = 'N');
1858:
1859: row_count := SQL%ROWCOUNT;
1860: GL_MESSAGE.Write_Log(msg_name => 'SHRD0118',
1861: token_num => 2,
1862: t1 => 'NUM',
1863: v1 => TO_CHAR(row_count),
1864: t2 => 'TABLE',

Line 1868: GL_MESSAGE.Func_Succ

1864: t2 => 'TABLE',
1865: v2 => 'GL_ACCESS_SET_ASSIGNMENTS');
1866: row_count := 0;
1867:
1868: GL_MESSAGE.Func_Succ
1869: (func_name => 'GL_FLATTEN_ACCESS_SETS.Enable_Record');
1870:
1871: RETURN TRUE;
1872:

Line 1875: GL_MESSAGE.Write_Log

1871: RETURN TRUE;
1872:
1873: EXCEPTION
1874: WHEN OTHERS THEN
1875: GL_MESSAGE.Write_Log
1876: (msg_name => 'SHRD0203',
1877: token_num => 2,
1878: t1 => 'FUNCTION',
1879: v1 => 'GL_FLATTEN_ACCESS_SETS.Enable_Record()',

Line 1883: GL_MESSAGE.Func_Fail

1879: v1 => 'GL_FLATTEN_ACCESS_SETS.Enable_Record()',
1880: t2 => 'SQLERRMC',
1881: v2 => SQLERRM);
1882:
1883: GL_MESSAGE.Func_Fail
1884: (func_name => 'GL_FLATTEN_ACCESS_SETS.Enable_Record');
1885:
1886: RETURN FALSE;
1887:

Line 1896: GL_MESSAGE.Func_Ent

1892: FUNCTION Clean_Up_By_Coa RETURN BOOLEAN IS
1893: row_count NUMBER := 0;
1894: BEGIN
1895:
1896: GL_MESSAGE.Func_Ent
1897: (func_name => 'GL_FLATTEN_ACCESS_SETS.Clean_Up_By_Coa');
1898:
1899: -- Run the following statements using the right parameters
1900: -- to clean up GL_ACCESS_SET_NORM_ASSIGN

Line 1903: GL_MESSAGE.Write_Log

1899: -- Run the following statements using the right parameters
1900: -- to clean up GL_ACCESS_SET_NORM_ASSIGN
1901:
1902: IF (GL_FLATTEN_SETUP_DATA.GLSTFL_Debug) THEN
1903: GL_MESSAGE.Write_Log
1904: (msg_name => 'SHRD0180',
1905: token_num => 2,
1906: t1 => 'ROUTINE',
1907: v1 => 'Clean_Up_By_Coa()',

Line 1939: GL_MESSAGE.Write_Log(msg_name => 'SHRD0119',

1935:
1936: END IF;
1937:
1938: row_count := SQL%ROWCOUNT;
1939: GL_MESSAGE.Write_Log(msg_name => 'SHRD0119',
1940: token_num => 2,
1941: t1 => 'NUM',
1942: v1 => TO_CHAR(row_count),
1943: t2 => 'TABLE',

Line 1948: GL_MESSAGE.Write_Log

1944: v2 => 'GL_ACCESS_SET_NORM_ASSIGN');
1945: row_count := 0;
1946:
1947: IF (GL_FLATTEN_SETUP_DATA.GLSTFL_Debug) THEN
1948: GL_MESSAGE.Write_Log
1949: (msg_name => 'SHRD0180',
1950: token_num => 2,
1951: t1 => 'ROUTINE',
1952: v1 => 'Clean_Up_By_Coa()',

Line 1999: GL_MESSAGE.Write_Log(msg_name => 'SHRD0118',

1995:
1996: END IF;
1997:
1998: row_count := SQL%ROWCOUNT;
1999: GL_MESSAGE.Write_Log(msg_name => 'SHRD0118',
2000: token_num => 2,
2001: t1 => 'NUM',
2002: v1 => TO_CHAR(row_count),
2003: t2 => 'TABLE',

Line 2007: GL_MESSAGE.Func_Succ

2003: t2 => 'TABLE',
2004: v2 => 'GL_ACCESS_SET_NORM_ASSIGN');
2005: row_count := 0;
2006:
2007: GL_MESSAGE.Func_Succ
2008: (func_name => 'GL_FLATTEN_ACCESS_SETS.Clean_Up_By_Coa');
2009:
2010: RETURN TRUE;
2011:

Line 2014: GL_MESSAGE.Write_Log

2010: RETURN TRUE;
2011:
2012: EXCEPTION
2013: WHEN OTHERS THEN
2014: GL_MESSAGE.Write_Log
2015: (msg_name => 'SHRD0203',
2016: token_num => 2,
2017: t1 => 'FUNCTION',
2018: v1 => 'GL_FLATTEN_ACCESS_SETS.Clean_Up_By_Coa()',

Line 2022: GL_MESSAGE.Func_Fail

2018: v1 => 'GL_FLATTEN_ACCESS_SETS.Clean_Up_By_Coa()',
2019: t2 => 'SQLERRMC',
2020: v2 => SQLERRM);
2021:
2022: GL_MESSAGE.Func_Fail
2023: (func_name => 'GL_FLATTEN_ACCESS_SETS.Clean_Up_By_Coa');
2024:
2025: RETURN FALSE;
2026: