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_ACCESS_SET_ASSIGN_INT

Line 349: -- all changes to access sets and populate GL_ACCESS_SET_ASSIGN_INT.

345: curr_seg_val VARCHAR2(15) := NULL;
346: BEGIN
347:
348: -- This routine will call Populate_Temp_Table to process
349: -- all changes to access sets and populate GL_ACCESS_SET_ASSIGN_INT.
350: -- After determining which access set assignments should be
351: -- effective, all final data will be populated back to
352: -- GL_ACCESS_SET_ASSIGNMENTS.
353: -- Here is the sequence of events:

Line 357: -- GL_ACCESS_SET_ASSIGN_INT

353: -- Here is the sequence of events:
354: -- 1) For modes VH, LH, LS and AS, obtain a shared lock on both
355: -- the balancing and the management segments.
356: -- 2) Call Populate_Temp_Table to populate data into
357: -- GL_ACCESS_SET_ASSIGN_INT
358: -- 3) Delete records from GL_ACCESS_SET_ASSIGNMENTS based on
359: -- GL_ACCESS_SET_ASSIGN_INT
360: -- 4) Call Enable_Record to enable/disable correct assignments in
361: -- GL_ACCESS_SET_ASSIGNMENTS.

Line 359: -- GL_ACCESS_SET_ASSIGN_INT

355: -- the balancing and the management segments.
356: -- 2) Call Populate_Temp_Table to populate data into
357: -- GL_ACCESS_SET_ASSIGN_INT
358: -- 3) Delete records from GL_ACCESS_SET_ASSIGNMENTS based on
359: -- GL_ACCESS_SET_ASSIGN_INT
360: -- 4) Call Enable_Record to enable/disable correct assignments in
361: -- GL_ACCESS_SET_ASSIGNMENTS.
362: -- 5) Insert new records into GL_ACCESS_SET_ASSIGNMENTS
363: -- 6) For modes LH and VH, update records in GL_ACCESS_SET_ASSIGNMENTS.

Line 444: -- GL_ACCESS_SET_ASSIGN_INT

440: RAISE GLSTFL_fatal_err;
441: END IF;
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,

Line 460: FROM GL_ACCESS_SET_ASSIGN_INT glasai

456: WHERE (ABS(glasa.access_set_id), glasa.ledger_id,
457: glasa.segment_value, glasa.parent_record_id) IN
458: (SELECT glasai.access_set_id, glasai.ledger_id,
459: glasai.segment_value, glasai.parent_record_id
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',

Line 488: FROM GL_ACCESS_SET_ASSIGN_INT;

484:
485: BEGIN
486: SELECT count(*)
487: INTO row_count
488: FROM GL_ACCESS_SET_ASSIGN_INT;
489: EXCEPTION
490: WHEN NO_DATA_FOUND THEN
491: row_count := 0;
492: END;

Line 500: v2 => 'GL_ACCESS_SET_ASSIGN_INT has ' || TO_CHAR(row_count) ||

496: token_num => 2,
497: t1 => 'ROUTINE',
498: v1 => 'Fix_Flattened_Table()',
499: t2 => 'ACTION',
500: v2 => 'GL_ACCESS_SET_ASSIGN_INT has ' || TO_CHAR(row_count) ||
501: ' records...');
502:
503: row_count := 0;
504: END IF;

Line 527: FROM GL_ACCESS_SET_ASSIGN_INT glasai

523: GL_FLATTEN_SETUP_DATA.GLSTFL_USER_ID,
524: GL_FLATTEN_SETUP_DATA.GLSTFL_LOGIN_ID, SYSDATE,
525: GL_FLATTEN_SETUP_DATA.GLSTFL_USER_ID,
526: glasai.start_date, glasai.end_date
527: FROM GL_ACCESS_SET_ASSIGN_INT glasai
528: WHERE glasai.status_code = 'I'
529: AND NOT EXISTS
530: (SELECT 1
531: FROM GL_ACCESS_SET_ASSIGNMENTS glasa

Line 578: GL_ACCESS_SET_ASSIGN_INT glasai,

574:
575: SELECT 1
576: INTO row_count
577: FROM GL_ACCESS_SETS glas,
578: GL_ACCESS_SET_ASSIGN_INT glasai,
579: GL_ACCESS_SET_ASSIGNMENTS glasa1,
580: GL_ACCESS_SET_ASSIGNMENTS glasa2
581: WHERE ( glas.secured_seg_value_set_id =
582: GL_FLATTEN_SETUP_DATA.GLSTFL_MGT_VS_ID

Line 624: GL_ACCESS_SET_ASSIGN_INT glasai,

620: DECLARE
621: CURSOR overlap_dates_cursor IS
622: SELECT distinct glas.name, gll.name, glasa1.segment_value
623: FROM GL_ACCESS_SETS glas,
624: GL_ACCESS_SET_ASSIGN_INT glasai,
625: GL_ACCESS_SET_ASSIGNMENTS glasa1,
626: GL_ACCESS_SET_ASSIGNMENTS glasa2,
627: GL_LEDGERS gll
628: WHERE ( glas.secured_seg_value_set_id =

Line 738: -- This routine will populate GL_ACCESS_SET_ASSIGN_INT based on

734: as_single_val_changed BOOLEAN := TRUE;
735: as_parent_val_changed BOOLEAN := TRUE;
736: BEGIN
737:
738: -- This routine will populate GL_ACCESS_SET_ASSIGN_INT based on
739: -- the mode of operation. Since this is a relatively expensive
740: -- operation, we will only do work when there are indeed changes
741: -- that will affect the access sets.
742: -- Here is the sequence of events:

Line 746: -- GL_ACCESS_SET_ASSIGN_INT based on the mode of operation.

742: -- Here is the sequence of events:
743: -- 1) For modes FF, SH, LS and AS, check if further processing is
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:

Line 922: -- populating GL_ACCESS_SET_ASSIGN_INT for various modes

918: v1 => GL_FLATTEN_SETUP_DATA.GLSTFL_OP_MODE);
919: END IF;
920:
921: -- Since changes related to access sets are found, start
922: -- populating GL_ACCESS_SET_ASSIGN_INT for various modes
923: -- of operation.
924:
925: IF (GL_FLATTEN_SETUP_DATA.GLSTFL_OP_MODE IN ('FF', 'SH')) THEN
926:

Line 942: 'GL_ACCESS_SET_ASSIGN_INT for segment ' ||

938: t1 => 'ROUTINE',
939: v1 => 'Populate_Temp_Table()',
940: t2 => 'ACTION',
941: v2 => 'Inserting records into ' ||
942: 'GL_ACCESS_SET_ASSIGN_INT for segment ' ||
943: 'value hierarchy changes...');
944: END IF;
945:
946: INSERT into GL_ACCESS_SET_ASSIGN_INT

Line 946: INSERT into GL_ACCESS_SET_ASSIGN_INT

942: 'GL_ACCESS_SET_ASSIGN_INT for segment ' ||
943: 'value hierarchy changes...');
944: END IF;
945:
946: INSERT into GL_ACCESS_SET_ASSIGN_INT
947: (access_set_id, ledger_id, segment_value, access_privilege_code,
948: status_code, parent_record_id, last_update_date, last_updated_by,
949: last_update_login, creation_date, created_by, start_date, end_date)
950: (SELECT glasna.access_set_id,

Line 992: v2 => 'GL_ACCESS_SET_ASSIGN_INT');

988: token_num => 2,
989: t1 => 'NUM',
990: v1 => TO_CHAR(row_count),
991: t2 => 'TABLE',
992: v2 => 'GL_ACCESS_SET_ASSIGN_INT');
993: row_count := 0;
994: END IF;
995:
996: -- If there are new segment values added to the value set and

Line 1010: 'GL_ACCESS_SET_ASSIGN_INT for new ' ||

1006: t1 => 'ROUTINE',
1007: v1 => 'Populate_Temp_Table()',
1008: t2 => 'ACTION',
1009: v2 => 'Inserting records into ' ||
1010: 'GL_ACCESS_SET_ASSIGN_INT for new ' ||
1011: 'segment values...');
1012: END IF;
1013:
1014: INSERT into GL_ACCESS_SET_ASSIGN_INT

Line 1014: INSERT into GL_ACCESS_SET_ASSIGN_INT

1010: 'GL_ACCESS_SET_ASSIGN_INT for new ' ||
1011: 'segment values...');
1012: END IF;
1013:
1014: INSERT into GL_ACCESS_SET_ASSIGN_INT
1015: (access_set_id, ledger_id, segment_value, access_privilege_code,
1016: status_code, parent_record_id, last_update_date, last_updated_by,
1017: last_update_login, creation_date, created_by, start_date, end_date)
1018: (SELECT glasna.access_set_id,

Line 1049: v2 => 'GL_ACCESS_SET_ASSIGN_INT');

1045: token_num => 2,
1046: t1 => 'NUM',
1047: v1 => TO_CHAR(row_count),
1048: t2 => 'TABLE',
1049: v2 => 'GL_ACCESS_SET_ASSIGN_INT');
1050: row_count := 0;
1051:
1052: END IF; -- IF (sh_ff_all_val_changed)...
1053:

Line 1066: 'GL_ACCESS_SET_ASSIGN_INT for legal ' ||

1062: t1 => 'ROUTINE',
1063: v1 => 'Populate_Temp_Table()',
1064: t2 => 'ACTION',
1065: v2 => 'Inserting records into ' ||
1066: 'GL_ACCESS_SET_ASSIGN_INT for legal ' ||
1067: 'and management implicit access sets...');
1068: END IF;
1069:
1070: -- This statement will process implicit access set changes from

Line 1073: INSERT into GL_ACCESS_SET_ASSIGN_INT

1069:
1070: -- This statement will process implicit access set changes from
1071: -- legal hierarchies.
1072:
1073: INSERT into GL_ACCESS_SET_ASSIGN_INT
1074: (access_set_id, ledger_id, segment_value, access_privilege_code,
1075: status_code, parent_record_id, last_update_date, last_updated_by,
1076: last_update_login, creation_date, created_by, start_date, end_date)
1077: (SELECT glasna.access_set_id, glasna.ledger_id,

Line 1101: v2 => 'GL_ACCESS_SET_ASSIGN_INT');

1097: token_num => 2,
1098: t1 => 'NUM',
1099: v1 => TO_CHAR(row_count),
1100: t2 => 'TABLE',
1101: v2 => 'GL_ACCESS_SET_ASSIGN_INT');
1102: row_count := 0;
1103:
1104:
1105: ELSIF (GL_FLATTEN_SETUP_DATA.GLSTFL_OP_MODE IN ('LS', 'VS')) THEN

Line 1121: 'GL_ACCESS_SET_ASSIGN_INT for changed ' ||

1117: t1 => 'ROUTINE',
1118: v1 => 'Populate_Temp_Table()',
1119: t2 => 'ACTION',
1120: v2 => 'Inserting records into ' ||
1121: 'GL_ACCESS_SET_ASSIGN_INT for changed ' ||
1122: 'ledger sets ' ||
1123: 'contained in full ledger type access sets ' ||
1124: 'or access assignment with a single segment '||
1125: 'value...');

Line 1131: INSERT into GL_ACCESS_SET_ASSIGN_INT

1127:
1128: -- This statement will not join to GL_SEG_VAL_HIERARCHIES since
1129: -- it only process changes in explicit ledger sets in full ledger
1130: -- type access sets, or access assignment with a single segment value.
1131: INSERT into GL_ACCESS_SET_ASSIGN_INT
1132: (access_set_id, ledger_id, segment_value, access_privilege_code,
1133: status_code, parent_record_id, last_update_date, last_updated_by,
1134: last_update_login, creation_date, created_by, start_date, end_date)
1135: (SELECT glasna.access_set_id, gllsa.ledger_id,

Line 1164: v2 => 'GL_ACCESS_SET_ASSIGN_INT');

1160: token_num => 2,
1161: t1 => 'NUM',
1162: v1 => TO_CHAR(row_count),
1163: t2 => 'TABLE',
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

Line 1175: 'GL_ACCESS_SET_ASSIGN_INT for access sets ' ||

1171: t1 => 'ROUTINE',
1172: v1 => 'Populate_Temp_Table()',
1173: t2 => 'ACTION',
1174: v2 => 'Inserting records into ' ||
1175: 'GL_ACCESS_SET_ASSIGN_INT for access sets ' ||
1176: 'containing changed explicit ledger sets ' ||
1177: 'with all segment values assigned...');
1178: END IF;
1179:

Line 1180: INSERT into GL_ACCESS_SET_ASSIGN_INT

1176: 'containing changed explicit ledger sets ' ||
1177: 'with all segment values assigned...');
1178: END IF;
1179:
1180: INSERT into GL_ACCESS_SET_ASSIGN_INT
1181: (access_set_id, ledger_id, segment_value, access_privilege_code,
1182: status_code, parent_record_id, last_update_date, last_updated_by,
1183: last_update_login, creation_date, created_by, start_date, end_date)
1184: (SELECT glasna.access_set_id, gllsa.ledger_id,

Line 1216: v2 => 'GL_ACCESS_SET_ASSIGN_INT');

1212: token_num => 2,
1213: t1 => 'NUM',
1214: v1 => TO_CHAR(row_count),
1215: t2 => 'TABLE',
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

Line 1227: 'GL_ACCESS_SET_ASSIGN_INT for access sets ' ||

1223: t1 => 'ROUTINE',
1224: v1 => 'Populate_Temp_Table()',
1225: t2 => 'ACTION',
1226: v2 => 'Inserting records into ' ||
1227: 'GL_ACCESS_SET_ASSIGN_INT for access sets ' ||
1228: 'containing changed explicit ledger sets ' ||
1229: 'with parent segment values assigned...');
1230: END IF;
1231:

Line 1232: INSERT into GL_ACCESS_SET_ASSIGN_INT

1228: 'containing changed explicit ledger sets ' ||
1229: 'with parent segment values assigned...');
1230: END IF;
1231:
1232: INSERT into GL_ACCESS_SET_ASSIGN_INT
1233: (access_set_id, ledger_id, segment_value, access_privilege_code,
1234: status_code, parent_record_id, last_update_date, last_updated_by,
1235: last_update_login, creation_date, created_by, start_date, end_date)
1236: (SELECT glasna.access_set_id, gllsa.ledger_id,

Line 1269: v2 => 'GL_ACCESS_SET_ASSIGN_INT');

1265: token_num => 2,
1266: t1 => 'NUM',
1267: v1 => TO_CHAR(row_count),
1268: t2 => 'TABLE',
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

Line 1280: 'GL_ACCESS_SET_ASSIGN_INT for implicit ' ||

1276: t1 => 'ROUTINE',
1277: v1 => 'Populate_Temp_Table()',
1278: t2 => 'ACTION',
1279: v2 => 'Inserting records into ' ||
1280: 'GL_ACCESS_SET_ASSIGN_INT for implicit ' ||
1281: 'access sets associated with changed ' ||
1282: 'explicit ledger sets... ');
1283: END IF;
1284:

Line 1285: INSERT into GL_ACCESS_SET_ASSIGN_INT

1281: 'access sets associated with changed ' ||
1282: 'explicit ledger sets... ');
1283: END IF;
1284:
1285: INSERT into GL_ACCESS_SET_ASSIGN_INT
1286: (access_set_id, ledger_id, segment_value, access_privilege_code,
1287: status_code, parent_record_id, last_update_date, last_updated_by,
1288: last_update_login, creation_date, created_by, start_date, end_date)
1289: (SELECT glasna.access_set_id, gllsa.ledger_id,

Line 1315: v2 => 'GL_ACCESS_SET_ASSIGN_INT');

1311: token_num => 2,
1312: t1 => 'NUM',
1313: v1 => TO_CHAR(row_count),
1314: t2 => 'TABLE',
1315: v2 => 'GL_ACCESS_SET_ASSIGN_INT');
1316: row_count := 0;
1317:
1318: ELSIF (GL_FLATTEN_SETUP_DATA.GLSTFL_OP_MODE = 'AS') THEN
1319:

Line 1336: 'GL_ACCESS_SET_ASSIGN_INT for changed ' ||

1332: t1 => 'ROUTINE',
1333: v1 => 'Populate_Temp_Table()',
1334: t2 => 'ACTION',
1335: v2 => 'Inserting records into ' ||
1336: 'GL_ACCESS_SET_ASSIGN_INT for changed ' ||
1337: 'access sets having full ledger access or ' ||
1338: 'access assignments with single segment ' ||
1339: 'value assigned...');
1340: END IF;

Line 1342: INSERT into GL_ACCESS_SET_ASSIGN_INT

1338: 'access assignments with single segment ' ||
1339: 'value assigned...');
1340: END IF;
1341:
1342: INSERT into GL_ACCESS_SET_ASSIGN_INT
1343: (access_set_id, ledger_id, segment_value, access_privilege_code,
1344: status_code, parent_record_id, last_update_date, last_updated_by,
1345: last_update_login, creation_date, created_by, start_date, end_date)
1346: (SELECT glasna.access_set_id,

Line 1377: v2 => 'GL_ACCESS_SET_ASSIGN_INT');

1373: token_num => 2,
1374: t1 => 'NUM',
1375: v1 => TO_CHAR(row_count),
1376: t2 => 'TABLE',
1377: v2 => 'GL_ACCESS_SET_ASSIGN_INT');
1378: row_count := 0;
1379: END IF; -- IF (as_single_val_changed) ...
1380:
1381: IF (as_all_val_changed) THEN

Line 1391: 'GL_ACCESS_SET_ASSIGN_INT for changed ' ||

1387: t1 => 'ROUTINE',
1388: v1 => 'Populate_Temp_Table()',
1389: t2 => 'ACTION',
1390: v2 => 'Inserting records into ' ||
1391: 'GL_ACCESS_SET_ASSIGN_INT for changed ' ||
1392: 'access sets having access assignments ' ||
1393: 'with all segment values assigned...');
1394: END IF;
1395:

Line 1396: INSERT into GL_ACCESS_SET_ASSIGN_INT

1392: 'access sets having access assignments ' ||
1393: 'with all segment values assigned...');
1394: END IF;
1395:
1396: INSERT into GL_ACCESS_SET_ASSIGN_INT
1397: (access_set_id, ledger_id, segment_value, access_privilege_code,
1398: status_code, parent_record_id, last_update_date, last_updated_by,
1399: last_update_login, creation_date, created_by, start_date, end_date)
1400: (SELECT glasna.access_set_id,

Line 1433: v2 => 'GL_ACCESS_SET_ASSIGN_INT');

1429: token_num => 2,
1430: t1 => 'NUM',
1431: v1 => TO_CHAR(row_count),
1432: t2 => 'TABLE',
1433: v2 => 'GL_ACCESS_SET_ASSIGN_INT');
1434: row_count := 0;
1435: END IF; -- IF (as_all_val_changed) ...
1436:
1437: IF (as_parent_val_changed) THEN

Line 1447: 'GL_ACCESS_SET_ASSIGN_INT for changed ' ||

1443: t1 => 'ROUTINE',
1444: v1 => 'Populate_Temp_Table()',
1445: t2 => 'ACTION',
1446: v2 => 'Inserting records into ' ||
1447: 'GL_ACCESS_SET_ASSIGN_INT for changed ' ||
1448: 'access sets having parent segment values ' ||
1449: 'assigned...');
1450: END IF;
1451:

Line 1452: INSERT into GL_ACCESS_SET_ASSIGN_INT

1448: 'access sets having parent segment values ' ||
1449: 'assigned...');
1450: END IF;
1451:
1452: INSERT into GL_ACCESS_SET_ASSIGN_INT
1453: (access_set_id, ledger_id, segment_value, access_privilege_code,
1454: status_code, parent_record_id, last_update_date, last_updated_by,
1455: last_update_login, creation_date, created_by, start_date, end_date)
1456: (SELECT glasna.access_set_id,

Line 1490: v2 => 'GL_ACCESS_SET_ASSIGN_INT');

1486: token_num => 2,
1487: t1 => 'NUM',
1488: v1 => TO_CHAR(row_count),
1489: t2 => 'TABLE',
1490: v2 => 'GL_ACCESS_SET_ASSIGN_INT');
1491: row_count := 0;
1492: END IF; -- IF (as_parent_val_changed) ...
1493:
1494: END IF; -- IF (...OP_MODE IN ('SH', 'FF')) THEN ...

Line 1548: FROM GL_ACCESS_SET_ASSIGN_INT glasai,

1544:
1545: CURSOR dup_access_assign_cursor IS
1546: SELECT DISTINCT MIN(glasai.access_set_id),
1547: MIN(glasai.ledger_id), MIN(glasai.segment_value)
1548: FROM GL_ACCESS_SET_ASSIGN_INT glasai,
1549: GL_ACCESS_SETS glas
1550: WHERE glasai.status_code = 'I'
1551: AND glasai.access_set_id > 0
1552: AND glas.access_set_id = ABS(glasai.access_set_id)

Line 1573: -- 2) Disable records in GL_ACCESS_SET_ASSIGN_INT based on effective

1569: -- always be enabled.
1570: -- The sequence of events is as follows:
1571: -- 1) Enable records in GL_ACCESS_SET_ASSIGNMENTS since the
1572: -- effective record might be deleted.
1573: -- 2) Disable records in GL_ACCESS_SET_ASSIGN_INT based on effective
1574: -- records in GL_ACCESS_SET_ASSIGNMENTS.
1575: -- 3) Pick the record in GL_ACCESS_SET_ASSIGN_INT having the greatest
1576: -- access code with the smallest rowid, then disable all other records.
1577: -- 4) Disable records in GL_ACCESS_SET_ASSIGNMENTS if there exists an

Line 1575: -- 3) Pick the record in GL_ACCESS_SET_ASSIGN_INT having the greatest

1571: -- 1) Enable records in GL_ACCESS_SET_ASSIGNMENTS since the
1572: -- effective record might be deleted.
1573: -- 2) Disable records in GL_ACCESS_SET_ASSIGN_INT based on effective
1574: -- records in GL_ACCESS_SET_ASSIGNMENTS.
1575: -- 3) Pick the record in GL_ACCESS_SET_ASSIGN_INT having the greatest
1576: -- access code with the smallest rowid, then disable all other records.
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.

Line 1578: -- effective record in GL_ACCESS_SET_ASSIGN_INT that has a higher

1574: -- records in GL_ACCESS_SET_ASSIGNMENTS.
1575: -- 3) Pick the record in GL_ACCESS_SET_ASSIGN_INT having the greatest
1576: -- access code with the smallest rowid, then disable all other records.
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');

Line 1588: -- 'D' records in GL_ACCESS_SET_ASSIGN_INT to search

1584: -- Pick a record with access_privilege_code of B that has
1585: -- the smallest rowid, and disable all other records
1586: -- Note this will only happen when the current effective
1587: -- record has been deleted. Thus we can make use of the
1588: -- 'D' records in GL_ACCESS_SET_ASSIGN_INT to search
1589: -- for the new effective record.
1590: -- Also here we do not need to check if the access sets are
1591: -- implicit or not, since only explicit access sets will ever
1592: -- have records with a negative access_set_id. This is because

Line 1612: FROM GL_ACCESS_SET_ASSIGN_INT glasai,

1608: UPDATE GL_ACCESS_SET_ASSIGNMENTS glasa1
1609: SET glasa1.access_set_id = -glasa1.access_set_id
1610: WHERE glasa1.rowid IN
1611: (SELECT MIN(glasa2.rowid)
1612: FROM GL_ACCESS_SET_ASSIGN_INT glasai,
1613: GL_ACCESS_SET_ASSIGNMENTS glasa2,
1614: GL_ACCESS_SET_ASSIGNMENTS glasa3
1615: WHERE glasai.status_code = 'D'
1616: AND glasa2.access_set_id = -glasai.access_set_id

Line 1658: FROM GL_ACCESS_SET_ASSIGN_INT glasai,

1654: UPDATE GL_ACCESS_SET_ASSIGNMENTS glasa1
1655: SET glasa1.access_set_id = -glasa1.access_set_id
1656: WHERE glasa1.rowid IN
1657: (SELECT MIN(glasa2.rowid)
1658: FROM GL_ACCESS_SET_ASSIGN_INT glasai,
1659: GL_ACCESS_SET_ASSIGNMENTS glasa2,
1660: GL_ACCESS_SET_ASSIGNMENTS glasa3
1661: WHERE glasai.status_code = 'D'
1662: AND glasa2.access_set_id = -glasai.access_set_id

Line 1684: -- corresponding record(s) in GL_ACCESS_SET_ASSIGN_INT.

1680: row_count := 0;
1681:
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,

Line 1693: 'GL_ACCESS_SET_ASSIGN_INT based on ' ||

1689: t1 => 'ROUTINE',
1690: v1 => 'Enable_Record()',
1691: t2 => 'ACTION',
1692: v2 => 'Updating records in ' ||
1693: 'GL_ACCESS_SET_ASSIGN_INT based on ' ||
1694: 'GL_ACCESS_SET_ASSIGNMENTS to disable ' ||
1695: 'access assignments...');
1696: END IF;
1697:

Line 1698: UPDATE GL_ACCESS_SET_ASSIGN_INT glasai1

1694: 'GL_ACCESS_SET_ASSIGNMENTS to disable ' ||
1695: 'access assignments...');
1696: END IF;
1697:
1698: UPDATE GL_ACCESS_SET_ASSIGN_INT glasai1
1699: SET glasai1.access_set_id = -glasai1.access_set_id
1700: WHERE glasai1.rowid IN
1701: (SELECT glasai2.rowid
1702: FROM GL_ACCESS_SET_ASSIGN_INT glasai2,

Line 1702: FROM GL_ACCESS_SET_ASSIGN_INT glasai2,

1698: UPDATE GL_ACCESS_SET_ASSIGN_INT glasai1
1699: SET glasai1.access_set_id = -glasai1.access_set_id
1700: WHERE glasai1.rowid IN
1701: (SELECT glasai2.rowid
1702: FROM GL_ACCESS_SET_ASSIGN_INT glasai2,
1703: GL_ACCESS_SETS glas,
1704: GL_ACCESS_SET_ASSIGNMENTS glasa
1705: WHERE glasai2.status_code = 'I'
1706: AND glasai2.access_set_id > 0

Line 1722: v2 => 'GL_ACCESS_SET_ASSIGN_INT');

1718: token_num => 2,
1719: t1 => 'NUM',
1720: v1 => TO_CHAR(row_count),
1721: t2 => 'TABLE',
1722: v2 => 'GL_ACCESS_SET_ASSIGN_INT');
1723: row_count := 0;
1724:
1725:
1726: IF (GL_FLATTEN_SETUP_DATA.GLSTFL_Debug) THEN

Line 1734: 'GL_ACCESS_SET_ASSIGN_INT with access ' ||

1730: t1 => 'ROUTINE',
1731: v1 => 'Enable_Record()',
1732: t2 => 'ACTION',
1733: v2 => 'Searching for records in ' ||
1734: 'GL_ACCESS_SET_ASSIGN_INT with access ' ||
1735: 'privilege B which has the smallest ' ||
1736: 'rowid, then disable all other records...');
1737: END IF;
1738:

Line 1740: -- GL_ACCESS_SET_ASSIGN_INT are unique, i.e. only 1 record

1736: 'rowid, then disable all other records...');
1737: END IF;
1738:
1739: -- For efficiency purposes, if all the records within
1740: -- GL_ACCESS_SET_ASSIGN_INT are unique, i.e. only 1 record
1741: -- exists in the table for each access_set_id/ledger_id/segment_value
1742: -- combination, the program will not need to run the enabling code
1743: -- within GL_ACCESS_SET_ASSIGN_INT. This is because no rows will
1744: -- be updated in the end.

Line 1743: -- within GL_ACCESS_SET_ASSIGN_INT. This is because no rows will

1739: -- For efficiency purposes, if all the records within
1740: -- GL_ACCESS_SET_ASSIGN_INT are unique, i.e. only 1 record
1741: -- exists in the table for each access_set_id/ledger_id/segment_value
1742: -- combination, the program will not need to run the enabling code
1743: -- within GL_ACCESS_SET_ASSIGN_INT. This is because no rows will
1744: -- be updated in the end.
1745: IF (NOT dup_access_assign_cursor%ISOPEN) THEN
1746: OPEN dup_access_assign_cursor;
1747: END IF;

Line 1775: UPDATE GL_ACCESS_SET_ASSIGN_INT glasai1

1771:
1772: -- Then, pick a record with access_privilege_code of B that has
1773: -- the smallest rowid, and disable all other records
1774:
1775: UPDATE GL_ACCESS_SET_ASSIGN_INT glasai1
1776: SET glasai1.access_set_id = -glasai1.access_set_id
1777: WHERE glasai1.access_set_id = curr_as_id
1778: AND glasai1.ledger_id = curr_ldg_id
1779: AND glasai1.segment_value = curr_seg_val

Line 1783: FROM GL_ACCESS_SET_ASSIGN_INT glasai2,

1779: AND glasai1.segment_value = curr_seg_val
1780: AND glasai1.status_code = 'I'
1781: AND EXISTS
1782: (SELECT 1
1783: FROM GL_ACCESS_SET_ASSIGN_INT glasai2,
1784: GL_ACCESS_SETS glas
1785: WHERE glasai2.status_code IN ('I', 'U')
1786: AND glasai2.access_set_id = glasai1.access_set_id
1787: AND glasai2.ledger_id = glasai1.ledger_id

Line 1816: v2 => 'GL_ACCESS_SET_ASSIGN_INT');

1812: token_num => 2,
1813: t1 => 'NUM',
1814: v1 => TO_CHAR(row_count),
1815: t2 => 'TABLE',
1816: v2 => 'GL_ACCESS_SET_ASSIGN_INT');
1817: row_count := 0;
1818:
1819: CLOSE dup_access_assign_cursor;
1820:

Line 1824: -- GL_ACCESS_SET_ASSIGN_INT has access privilege of B.

1820:
1821: -- Here the only conflict that needs to be resolve is
1822: -- that the enabled record in GL_ACCESS_SET_ASSIGNMENTS has
1823: -- access privilege of R, while the enabled record in
1824: -- GL_ACCESS_SET_ASSIGN_INT has access privilege of B.
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

Line 1838: 'exists a record in GL_ACCESS_SET_ASSIGN_INT '||

1834: t2 => 'ACTION',
1835: v2 => 'Updating records in ' ||
1836: 'GL_ACCESS_SET_ASSIGNMENTS to disable ' ||
1837: 'those with access privilege R if there ' ||
1838: 'exists a record in GL_ACCESS_SET_ASSIGN_INT '||
1839: 'with access privilege of B...');
1840: END IF;
1841:
1842: UPDATE GL_ACCESS_SET_ASSIGNMENTS glasa

Line 1851: FROM GL_ACCESS_SET_ASSIGN_INT glasai,

1847: glasa.segment_value) IN
1848: (SELECT DISTINCT
1849: glasai.access_set_id, glasai.ledger_id,
1850: glasai.segment_value
1851: FROM GL_ACCESS_SET_ASSIGN_INT glasai,
1852: GL_ACCESS_SETS glas
1853: WHERE glasai.status_code IN ('I', 'U')
1854: AND glasai.access_privilege_code = 'B'
1855: AND glasai.access_set_id > 0