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.ICX_CAT_CNTNT_SCRTY_UPG_PVT dependencies on ICX_CAT_UTIL_PVT

Line 116: ICX_CAT_UTIL_PVT.logProcBegin(g_pkg_name, l_api_name, 'Start');

112: l_err_loc PLS_INTEGER;
113: BEGIN
114:
115: IF (FND_LOG.LEVEL_PROCEDURE >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
116: ICX_CAT_UTIL_PVT.logProcBegin(g_pkg_name, l_api_name, 'Start');
117: END IF;
118:
119: l_err_loc := 0;
120:

Line 197: ICX_CAT_UTIL_PVT.logProcEnd(g_pkg_name, l_api_name, 'End');

193: -- commit!
194: commit;
195:
196: IF (FND_LOG.LEVEL_PROCEDURE >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
197: ICX_CAT_UTIL_PVT.logProcEnd(g_pkg_name, l_api_name, 'End');
198: END IF;
199:
200: EXCEPTION
201: WHEN OTHERS THEN

Line 254: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, 'is_already_run'),

250: IF ((exists_non_seeded_data = 1) AND
251: (FND_LOG.LEVEL_EXCEPTION >= FND_LOG.G_CURRENT_RUNTIME_LEVEL)) THEN
252:
253: FND_LOG.string(FND_LOG.LEVEL_EXCEPTION,
254: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, 'is_already_run'),
255: 'Detected that script already run.');
256:
257: END IF;
258:

Line 285: l_icx_schema_name := ICX_CAT_UTIL_PVT.getIcxSchemaName();

281: BEGIN
282:
283: l_err_loc := 0;
284:
285: l_icx_schema_name := ICX_CAT_UTIL_PVT.getIcxSchemaName();
286: l_err_loc := 100;
287:
288: BEGIN
289:

Line 319: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, 'is_new_installation'),

315: IF ((exists_catalogs_data = -1) AND
316: (FND_LOG.LEVEL_EXCEPTION >= FND_LOG.G_CURRENT_RUNTIME_LEVEL)) THEN
317:
318: FND_LOG.string(FND_LOG.LEVEL_EXCEPTION,
319: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, 'is_new_installation'),
320: 'Detected that this is a new R12 installation.');
321:
322: END IF;
323:

Line 349: ICX_CAT_UTIL_PVT.logProcBegin(g_pkg_name, l_api_name, 'Start');

345: l_err_loc PLS_INTEGER;
346: BEGIN
347:
348: IF (FND_LOG.LEVEL_PROCEDURE >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
349: ICX_CAT_UTIL_PVT.logProcBegin(g_pkg_name, l_api_name, 'Start');
350: END IF;
351:
352: l_err_loc := 0;
353:

Line 379: ICX_CAT_UTIL_PVT.logProcEnd(g_pkg_name, l_api_name, 'End');

375:
376: l_err_loc := 300;
377:
378: IF (FND_LOG.LEVEL_PROCEDURE >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
379: ICX_CAT_UTIL_PVT.logProcEnd(g_pkg_name, l_api_name, 'End');
380: END IF;
381:
382: EXCEPTION
383: WHEN OTHERS THEN

Line 416: ICX_CAT_UTIL_PVT.logProcBegin(g_pkg_name, l_api_name, 'Start');

412: l_err_loc PLS_INTEGER;
413: BEGIN
414:
415: IF (FND_LOG.LEVEL_PROCEDURE >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
416: ICX_CAT_UTIL_PVT.logProcBegin(g_pkg_name, l_api_name, 'Start');
417: END IF;
418:
419: l_err_loc := 0;
420:

Line 453: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),

449: l_err_loc := 500;
450:
451: IF (FND_LOG.LEVEL_EXCEPTION >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
452: FND_LOG.string(FND_LOG.LEVEL_EXCEPTION,
453: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),
454: 'OU Profile ID='||g_ou_profile_id||', val(site)='||
455: g_site_ou_profile_value||', Approved Pricing Profile val(site)='
456: ||g_site_approved_pricing);
457: END IF;

Line 461: ICX_CAT_UTIL_PVT.logProcEnd(g_pkg_name, l_api_name, 'End');

457: END IF;
458: l_err_loc := 600;
459:
460: IF (FND_LOG.LEVEL_PROCEDURE >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
461: ICX_CAT_UTIL_PVT.logProcEnd(g_pkg_name, l_api_name, 'End');
462: END IF;
463:
464: EXCEPTION
465: WHEN OTHERS THEN

Line 489: ICX_CAT_UTIL_PVT.logProcBegin(g_pkg_name, l_api_name, 'Start');

485: l_err_loc PLS_INTEGER;
486: BEGIN
487:
488: IF (FND_LOG.LEVEL_PROCEDURE >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
489: ICX_CAT_UTIL_PVT.logProcBegin(g_pkg_name, l_api_name, 'Start');
490: END IF;
491:
492: l_err_loc := 0;
493:

Line 506: ICX_CAT_UTIL_PVT.logProcEnd(g_pkg_name, l_api_name, 'End');

502: FROM dual;
503: l_err_loc := 100;
504:
505: IF (FND_LOG.LEVEL_PROCEDURE >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
506: ICX_CAT_UTIL_PVT.logProcEnd(g_pkg_name, l_api_name, 'End');
507: END IF;
508:
509: EXCEPTION
510: WHEN OTHERS THEN

Line 530: ICX_CAT_UTIL_PVT.logProcBegin(g_pkg_name, l_api_name, 'Start');

526: l_err_loc PLS_INTEGER;
527: BEGIN
528:
529: IF (FND_LOG.LEVEL_PROCEDURE >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
530: ICX_CAT_UTIL_PVT.logProcBegin(g_pkg_name, l_api_name, 'Start');
531: END IF;
532:
533: l_err_loc := 0;
534:

Line 545: ICX_CAT_UTIL_PVT.logProcEnd(g_pkg_name, l_api_name, 'End');

541: FROM dual;
542: l_err_loc := 100;
543:
544: IF (FND_LOG.LEVEL_PROCEDURE >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
545: ICX_CAT_UTIL_PVT.logProcEnd(g_pkg_name, l_api_name, 'End');
546: END IF;
547:
548: EXCEPTION
549: WHEN OTHERS THEN

Line 605: ICX_CAT_UTIL_PVT.logProcBegin(g_pkg_name, l_api_name, 'Start');

601: l_err_loc PLS_INTEGER;
602: BEGIN
603:
604: IF (FND_LOG.LEVEL_PROCEDURE >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
605: ICX_CAT_UTIL_PVT.logProcBegin(g_pkg_name, l_api_name, 'Start');
606: END IF;
607:
608: l_err_loc := 0;
609:

Line 700: ICX_CAT_UTIL_PVT.logProcEnd(g_pkg_name, l_api_name, 'End');

696: migrate_seeded_store(10000000, 2);
697: l_err_loc := 1000;
698:
699: IF (FND_LOG.LEVEL_PROCEDURE >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
700: ICX_CAT_UTIL_PVT.logProcEnd(g_pkg_name, l_api_name, 'End');
701: END IF;
702:
703: EXCEPTION
704: WHEN OTHERS THEN

Line 747: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),

743:
744: -- log status of the old seeded store pre-R12
745: IF (FND_LOG.LEVEL_EXCEPTION >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
746: FND_LOG.string(FND_LOG.LEVEL_EXCEPTION,
747: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),
748: 'The old seeded Main Store status (1=>EXISTS) = '||l_has_main_store);
749: END IF;
750:
751: RETURN (l_has_main_store = 1);

Line 781: ICX_CAT_UTIL_PVT.logProcBegin(g_pkg_name, l_api_name,

777: l_err_loc PLS_INTEGER;
778: BEGIN
779:
780: IF (FND_LOG.LEVEL_PROCEDURE >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
781: ICX_CAT_UTIL_PVT.logProcBegin(g_pkg_name, l_api_name,
782: 'p_old_id='||p_old_id||';p_new_id='||p_new_id);
783: END IF;
784:
785: l_err_loc := 0;

Line 816: ICX_CAT_UTIL_PVT.logProcEnd(g_pkg_name, l_api_name, 'End');

812: g_stores_map(p_old_id) := p_new_id;
813: l_err_loc := 400;
814:
815: IF (FND_LOG.LEVEL_PROCEDURE >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
816: ICX_CAT_UTIL_PVT.logProcEnd(g_pkg_name, l_api_name, 'End');
817: END IF;
818:
819: EXCEPTION
820: WHEN OTHERS THEN

Line 839: ICX_CAT_UTIL_PVT.logProcBegin(g_pkg_name, l_api_name, 'Start');

835: l_err_loc PLS_INTEGER;
836: BEGIN
837:
838: IF (FND_LOG.LEVEL_PROCEDURE >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
839: ICX_CAT_UTIL_PVT.logProcBegin(g_pkg_name, l_api_name, 'Start');
840: END IF;
841:
842: l_err_loc := 0;
843:

Line 862: ICX_CAT_UTIL_PVT.logProcEnd(g_pkg_name, l_api_name, 'End');

858: WHERE content_id = 1;
859: l_err_loc := 300;
860:
861: IF (FND_LOG.LEVEL_PROCEDURE >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
862: ICX_CAT_UTIL_PVT.logProcEnd(g_pkg_name, l_api_name, 'End');
863: END IF;
864:
865: EXCEPTION
866: WHEN OTHERS THEN

Line 886: ICX_CAT_UTIL_PVT.logProcBegin(g_pkg_name, l_api_name, 'Start');

882: l_err_loc PLS_INTEGER;
883: BEGIN
884:
885: IF (FND_LOG.LEVEL_PROCEDURE >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
886: ICX_CAT_UTIL_PVT.logProcBegin(g_pkg_name, l_api_name, 'Start');
887: END IF;
888:
889: l_err_loc := 0;
890:

Line 906: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),

902: l_err_loc := 150;
903:
904: IF (FND_LOG.LEVEL_EXCEPTION >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
905: FND_LOG.string(FND_LOG.LEVEL_EXCEPTION,
906: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),
907: 'Pre-11.5.9 upgrade found no Category Realms being used.');
908: END IF;
909:
910: l_err_loc := 200;

Line 931: ICX_CAT_UTIL_PVT.logProcEnd(g_pkg_name, l_api_name, 'End');

927:
928: END IF;
929:
930: IF (FND_LOG.LEVEL_PROCEDURE >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
931: ICX_CAT_UTIL_PVT.logProcEnd(g_pkg_name, l_api_name, 'End');
932: END IF;
933:
934: EXCEPTION
935: WHEN OTHERS THEN

Line 958: ICX_CAT_UTIL_PVT.logProcBegin(g_pkg_name, l_api_name, 'Start');

954: l_err_loc PLS_INTEGER;
955: BEGIN
956:
957: IF (FND_LOG.LEVEL_PROCEDURE >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
958: ICX_CAT_UTIL_PVT.logProcBegin(g_pkg_name, l_api_name, 'Start');
959: END IF;
960:
961: l_err_loc := 0;
962:

Line 971: ICX_CAT_UTIL_PVT.logProcEnd(g_pkg_name, l_api_name, 'End');

967: promote_all_local_to_seeded();
968: l_err_loc := 100;
969:
970: IF (FND_LOG.LEVEL_PROCEDURE >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
971: ICX_CAT_UTIL_PVT.logProcEnd(g_pkg_name, l_api_name, 'End');
972: END IF;
973:
974: EXCEPTION
975: WHEN OTHERS THEN

Line 997: ICX_CAT_UTIL_PVT.logProcBegin(g_pkg_name, l_api_name, 'Start');

993: l_err_loc PLS_INTEGER;
994: BEGIN
995:
996: IF (FND_LOG.LEVEL_PROCEDURE >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
997: ICX_CAT_UTIL_PVT.logProcBegin(g_pkg_name, l_api_name, 'Start');
998: END IF;
999:
1000: l_err_loc := 0;
1001:

Line 1048: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),

1044: l_err_loc := 600;
1045:
1046: IF (FND_LOG.LEVEL_EXCEPTION >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
1047: FND_LOG.string(FND_LOG.LEVEL_EXCEPTION,
1048: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),
1049: 'Did not find an All Local Content to migrate to seeded status.');
1050: END IF;
1051:
1052: END;

Line 1055: ICX_CAT_UTIL_PVT.logProcEnd(g_pkg_name, l_api_name, 'End');

1051:
1052: END;
1053:
1054: IF (FND_LOG.LEVEL_PROCEDURE >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
1055: ICX_CAT_UTIL_PVT.logProcEnd(g_pkg_name, l_api_name, 'End');
1056: END IF;
1057:
1058: EXCEPTION
1059: WHEN OTHERS THEN

Line 1090: ICX_CAT_UTIL_PVT.logProcBegin(g_pkg_name, l_api_name, 'Start');

1086: l_err_loc PLS_INTEGER;
1087: BEGIN
1088:
1089: IF (FND_LOG.LEVEL_PROCEDURE >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
1090: ICX_CAT_UTIL_PVT.logProcBegin(g_pkg_name, l_api_name, 'Start');
1091: END IF;
1092:
1093: l_err_loc := 0;
1094: l_local_catalogs_migrated := FALSE;

Line 1130: ICX_CAT_UTIL_PVT.logProcEnd(g_pkg_name, l_api_name,

1126: l_err_loc := 500;
1127:
1128: IF (FND_LOG.LEVEL_PROCEDURE >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
1129: IF (l_local_catalogs_migrated) THEN
1130: ICX_CAT_UTIL_PVT.logProcEnd(g_pkg_name, l_api_name,
1131: 'Local Catalogs MIGRATED successfully.');
1132: ELSE
1133: ICX_CAT_UTIL_PVT.logProcEnd(g_pkg_name, l_api_name,
1134: 'Local Catalogs have NOT been migrated.');

Line 1133: ICX_CAT_UTIL_PVT.logProcEnd(g_pkg_name, l_api_name,

1129: IF (l_local_catalogs_migrated) THEN
1130: ICX_CAT_UTIL_PVT.logProcEnd(g_pkg_name, l_api_name,
1131: 'Local Catalogs MIGRATED successfully.');
1132: ELSE
1133: ICX_CAT_UTIL_PVT.logProcEnd(g_pkg_name, l_api_name,
1134: 'Local Catalogs have NOT been migrated.');
1135: END IF;
1136: END IF;
1137:

Line 1169: ICX_CAT_UTIL_PVT.logProcBegin(g_pkg_name, l_api_name, 'Start');

1165: l_err_loc PLS_INTEGER;
1166: BEGIN
1167:
1168: IF (FND_LOG.LEVEL_PROCEDURE >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
1169: ICX_CAT_UTIL_PVT.logProcBegin(g_pkg_name, l_api_name, 'Start');
1170: END IF;
1171:
1172: l_err_loc := 0;
1173: l_item_sources_migrated := FALSE;

Line 1214: ICX_CAT_UTIL_PVT.logProcEnd(g_pkg_name, l_api_name,

1210: l_err_loc := 600;
1211:
1212: IF (FND_LOG.LEVEL_PROCEDURE >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
1213: IF (l_item_sources_migrated) THEN
1214: ICX_CAT_UTIL_PVT.logProcEnd(g_pkg_name, l_api_name,
1215: 'Item Sources MIGRATED successfully.');
1216: ELSE
1217: ICX_CAT_UTIL_PVT.logProcEnd(g_pkg_name, l_api_name,
1218: 'Item Sources have NOT been migrated.');

Line 1217: ICX_CAT_UTIL_PVT.logProcEnd(g_pkg_name, l_api_name,

1213: IF (l_item_sources_migrated) THEN
1214: ICX_CAT_UTIL_PVT.logProcEnd(g_pkg_name, l_api_name,
1215: 'Item Sources MIGRATED successfully.');
1216: ELSE
1217: ICX_CAT_UTIL_PVT.logProcEnd(g_pkg_name, l_api_name,
1218: 'Item Sources have NOT been migrated.');
1219: END IF;
1220: END IF;
1221:

Line 1250: ICX_CAT_UTIL_PVT.logProcBegin(g_pkg_name, l_api_name, 'Start');

1246: l_err_loc PLS_INTEGER;
1247: BEGIN
1248:
1249: IF (FND_LOG.LEVEL_PROCEDURE >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
1250: ICX_CAT_UTIL_PVT.logProcBegin(g_pkg_name, l_api_name, 'Start');
1251: END IF;
1252:
1253: l_err_loc := 0;
1254:

Line 1266: ICX_CAT_UTIL_PVT.logProcEnd(g_pkg_name, l_api_name, 'End');

1262: migrate_catalogs_no_realms(l_catalog_ids, l_store_ids, l_new_zone_ids);
1263: l_err_loc := 200;
1264:
1265: IF (FND_LOG.LEVEL_PROCEDURE >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
1266: ICX_CAT_UTIL_PVT.logProcEnd(g_pkg_name, l_api_name, 'End');
1267: END IF;
1268:
1269: EXCEPTION
1270: WHEN OTHERS THEN

Line 1297: ICX_CAT_UTIL_PVT.logProcBegin(g_pkg_name, l_api_name, 'Start');

1293: l_err_loc PLS_INTEGER;
1294: BEGIN
1295:
1296: IF (FND_LOG.LEVEL_PROCEDURE >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
1297: ICX_CAT_UTIL_PVT.logProcBegin(g_pkg_name, l_api_name, 'Start');
1298: END IF;
1299:
1300: l_err_loc := 0;
1301:

Line 1318: ICX_CAT_UTIL_PVT.logProcEnd(g_pkg_name, l_api_name, 'End');

1314: update_exchange_punchouts();
1315: l_err_loc := 300;
1316:
1317: IF (FND_LOG.LEVEL_PROCEDURE >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
1318: ICX_CAT_UTIL_PVT.logProcEnd(g_pkg_name, l_api_name, 'End');
1319: END IF;
1320:
1321: EXCEPTION
1322: WHEN OTHERS THEN

Line 1409: ICX_CAT_UTIL_PVT.logProcBegin(g_pkg_name, l_api_name, 'Start');

1405:
1406: BEGIN
1407:
1408: IF (FND_LOG.LEVEL_PROCEDURE >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
1409: ICX_CAT_UTIL_PVT.logProcBegin(g_pkg_name, l_api_name, 'Start');
1410: END IF;
1411:
1412: l_err_loc := 0;
1413:

Line 1444: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),

1440: IF (l_content_types(i) = 'LOCAL') THEN
1441:
1442: IF (FND_LOG.LEVEL_STATEMENT >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
1443: FND_LOG.string(FND_LOG.LEVEL_STATEMENT,
1444: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),
1445: 'Processing Local Catalog ... '||l_old_content_ids(i)||
1446: ' for Store '||l_old_store_ids(i)||' (is NULL if empty).');
1447: END IF;
1448:

Line 1462: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),

1458: IF (l_resp_with_catr_realms.COUNT = 0) THEN
1459:
1460: IF (FND_LOG.LEVEL_STATEMENT >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
1461: FND_LOG.string(FND_LOG.LEVEL_STATEMENT,
1462: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),
1463: 'Local Catalog can be migrated WITHOUT realms.');
1464: END IF;
1465:
1466: l_catalog_no_catr_realms_ids.extend;

Line 1480: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),

1476: ELSE -- there are responsibilities with realms that can access this store
1477:
1478: IF (FND_LOG.LEVEL_STATEMENT >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
1479: FND_LOG.string(FND_LOG.LEVEL_STATEMENT,
1480: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),
1481: 'Local Catalog MUST be migrated WITH realms.');
1482: END IF;
1483:
1484: -- migrate this individual local catalog with realms consideration

Line 1496: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),

1492: ELSE -- for item sources (l_content_types(i) <> 'LOCAL')
1493:
1494: IF (FND_LOG.LEVEL_STATEMENT >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
1495: FND_LOG.string(FND_LOG.LEVEL_STATEMENT,
1496: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),
1497: 'Processing Item Source ... '||l_old_content_ids(i)||
1498: ' for Store '||l_old_store_ids(i)||' (is NULL if empty).');
1499: END IF;
1500:

Line 1518: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),

1514: l_err_loc := 550;
1515:
1516: IF (FND_LOG.LEVEL_STATEMENT >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
1517: FND_LOG.string(FND_LOG.LEVEL_STATEMENT,
1518: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),
1519: 'Processing Item Source ... same store, no need to re-query.');
1520: END IF;
1521:
1522: ELSE

Line 1526: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),

1522: ELSE
1523:
1524: IF (FND_LOG.LEVEL_STATEMENT >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
1525: FND_LOG.string(FND_LOG.LEVEL_STATEMENT,
1526: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),
1527: 'Processing Item Source ... a new store, MUST re-query.');
1528: END IF;
1529:
1530: l_err_loc := 600;

Line 1555: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),

1551: IF (l_resp_with_isrc_realms.COUNT = 0) THEN
1552:
1553: IF (FND_LOG.LEVEL_STATEMENT >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
1554: FND_LOG.string(FND_LOG.LEVEL_STATEMENT,
1555: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),
1556: 'Item Source can be migrated WITHOUT realms.');
1557: END IF;
1558:
1559: l_isrc_no_isrc_realms_ids.extend;

Line 1573: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),

1569: ELSE -- there are responsibilities with realms that can access this store
1570:
1571: IF (FND_LOG.LEVEL_STATEMENT >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
1572: FND_LOG.string(FND_LOG.LEVEL_STATEMENT,
1573: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),
1574: 'Item Source MUST be migrated WITH realms.');
1575: END IF;
1576:
1577: migrate_isrc_with_realms(l_old_content_ids(i), l_old_store_ids(i),

Line 1604: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),

1600: ELSE -- skip and log
1601:
1602: IF (FND_LOG.LEVEL_STATEMENT >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
1603: FND_LOG.string(FND_LOG.LEVEL_STATEMENT,
1604: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),
1605: 'Found no Local Catalogs that were migrate-able WITHOUT realms.');
1606: END IF;
1607:
1608: END IF;

Line 1625: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),

1621: ELSE -- skip and log
1622:
1623: IF (FND_LOG.LEVEL_STATEMENT >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
1624: FND_LOG.string(FND_LOG.LEVEL_STATEMENT,
1625: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),
1626: 'Found no Item Sources that were migrate-able WITHOUT realms.');
1627: END IF;
1628:
1629: END IF;

Line 1637: ICX_CAT_UTIL_PVT.logProcEnd(g_pkg_name, l_api_name, 'End');

1633: update_exchange_punchouts();
1634: l_err_loc := 1300;
1635:
1636: IF (FND_LOG.LEVEL_PROCEDURE >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
1637: ICX_CAT_UTIL_PVT.logProcEnd(g_pkg_name, l_api_name, 'End');
1638: END IF;
1639:
1640: EXCEPTION
1641: WHEN OTHERS THEN

Line 1681: ICX_CAT_UTIL_PVT.logProcBegin(g_pkg_name, l_api_name, 'Start');

1677: l_err_loc PLS_INTEGER;
1678: BEGIN
1679:
1680: IF (FND_LOG.LEVEL_PROCEDURE >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
1681: ICX_CAT_UTIL_PVT.logProcBegin(g_pkg_name, l_api_name, 'Start');
1682: END IF;
1683:
1684: l_err_loc := 0;
1685:

Line 1738: ICX_CAT_UTIL_PVT.logProcEnd(g_pkg_name, l_api_name, 'End');

1734: p_catalog_ids, p_old_store_ids);
1735: l_err_loc := 700;
1736:
1737: IF (FND_LOG.LEVEL_PROCEDURE >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
1738: ICX_CAT_UTIL_PVT.logProcEnd(g_pkg_name, l_api_name, 'End');
1739: END IF;
1740:
1741: EXCEPTION
1742: WHEN OTHERS THEN

Line 1789: ICX_CAT_UTIL_PVT.logProcBegin(g_pkg_name, l_api_name, 'Start');

1785: l_err_loc PLS_INTEGER;
1786: BEGIN
1787:
1788: IF (FND_LOG.LEVEL_PROCEDURE >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
1789: ICX_CAT_UTIL_PVT.logProcBegin(g_pkg_name, l_api_name, 'Start');
1790: END IF;
1791:
1792: l_err_loc := 0;
1793:

Line 1844: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),

1840: ELSE -- skip and log
1841:
1842: IF (FND_LOG.LEVEL_STATEMENT >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
1843: FND_LOG.string(FND_LOG.LEVEL_STATEMENT,
1844: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),
1845: 'Skipping adding zones migrated from Local Catalog '||p_catalog_id||
1846: ' to any R12 Stores because it did not belong to any Old Stores.');
1847: END IF;
1848:

Line 1855: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),

1851: ELSE -- skip and log
1852:
1853: IF (FND_LOG.LEVEL_STATEMENT >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
1854: FND_LOG.string(FND_LOG.LEVEL_STATEMENT,
1855: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),
1856: 'Skipping creating category-restricted zones from Local Catalog '||
1857: p_catalog_id||' in Old Store '||p_old_store_id||
1858: ' as there are no resps with realm values that can access it.');
1859: END IF;

Line 1909: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),

1905: ELSE -- skip and log
1906:
1907: IF (FND_LOG.LEVEL_STATEMENT >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
1908: FND_LOG.string(FND_LOG.LEVEL_STATEMENT,
1909: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),
1910: 'Skipping adding zone migrated from Local Catalog '||p_catalog_id||
1911: ' to any R12 Stores because it did not belong to any Old Stores.');
1912: END IF;
1913:

Line 1920: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),

1916: ELSE -- skip and log
1917:
1918: IF (FND_LOG.LEVEL_STATEMENT >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
1919: FND_LOG.string(FND_LOG.LEVEL_STATEMENT,
1920: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),
1921: 'Skipping creating category-unrestricted zone from Local Catalog '||
1922: p_catalog_id||' in Old Store '||p_old_store_id||
1923: ' as there are no resps without realms that can access it.');
1924: END IF;

Line 1931: ICX_CAT_UTIL_PVT.logProcEnd(g_pkg_name, l_api_name, 'End');

1927:
1928: l_err_loc := 1200;
1929:
1930: IF (FND_LOG.LEVEL_PROCEDURE >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
1931: ICX_CAT_UTIL_PVT.logProcEnd(g_pkg_name, l_api_name, 'End');
1932: END IF;
1933:
1934: EXCEPTION
1935: WHEN OTHERS THEN

Line 1971: ICX_CAT_UTIL_PVT.logProcBegin(g_pkg_name, l_api_name, 'Start');

1967: l_err_loc PLS_INTEGER;
1968: BEGIN
1969:
1970: IF (FND_LOG.LEVEL_PROCEDURE >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
1971: ICX_CAT_UTIL_PVT.logProcBegin(g_pkg_name, l_api_name, 'Start');
1972: END IF;
1973:
1974: l_err_loc := 0;
1975:

Line 2024: ICX_CAT_UTIL_PVT.logProcEnd(g_pkg_name, l_api_name, 'End');

2020: p_item_source_ids, p_old_store_ids);
2021: l_err_loc := 600;
2022:
2023: IF (FND_LOG.LEVEL_PROCEDURE >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
2024: ICX_CAT_UTIL_PVT.logProcEnd(g_pkg_name, l_api_name, 'End');
2025: END IF;
2026:
2027: EXCEPTION
2028: WHEN OTHERS THEN

Line 2082: ICX_CAT_UTIL_PVT.logProcBegin(g_pkg_name, l_api_name, 'Start');

2078: l_err_loc PLS_INTEGER;
2079: BEGIN
2080:
2081: IF (FND_LOG.LEVEL_PROCEDURE >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
2082: ICX_CAT_UTIL_PVT.logProcBegin(g_pkg_name, l_api_name, 'Start');
2083: END IF;
2084:
2085: l_err_loc := 0;
2086:

Line 2121: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),

2117:
2118: -- log out the responsibilties that can access this item source via realms
2119: IF (FND_LOG.LEVEL_EXCEPTION >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
2120: FND_LOG.string(FND_LOG.LEVEL_EXCEPTION,
2121: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),
2122: 'For migrating Item Source '||p_item_source_id||
2123: ' with Realms for Store '||p_old_store_id||
2124: ', the following responsibilities can access it:');
2125:

Line 2128: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),

2124: ', the following responsibilities can access it:');
2125:
2126: FOR i IN 1..l_resps_to_secure_by.COUNT LOOP
2127: FND_LOG.string(FND_LOG.LEVEL_EXCEPTION,
2128: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),
2129: 'Responsibility #'||i||'.'||l_resps_to_secure_by(i));
2130: END LOOP;
2131: END IF;
2132:

Line 2179: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),

2175: ELSE -- no responsibilities total can access this item source, skip it
2176:
2177: IF (FND_LOG.LEVEL_STATEMENT >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
2178: FND_LOG.string(FND_LOG.LEVEL_STATEMENT,
2179: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),
2180: 'Skipping Item Source '||p_item_source_id||' for Store '||
2181: p_old_store_id||' as no responsibilities can access it.');
2182: END IF;
2183:

Line 2189: ICX_CAT_UTIL_PVT.logProcEnd(g_pkg_name, l_api_name, 'End');

2185:
2186: l_err_loc := 700;
2187:
2188: IF (FND_LOG.LEVEL_PROCEDURE >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
2189: ICX_CAT_UTIL_PVT.logProcEnd(g_pkg_name, l_api_name, 'End');
2190: END IF;
2191:
2192: EXCEPTION
2193: WHEN OTHERS THEN

Line 2226: ICX_CAT_UTIL_PVT.logProcBegin(g_pkg_name, l_api_name, 'Start');

2222: l_err_loc PLS_INTEGER;
2223: BEGIN
2224:
2225: IF (FND_LOG.LEVEL_PROCEDURE >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
2226: ICX_CAT_UTIL_PVT.logProcBegin(g_pkg_name, l_api_name, 'Start');
2227: END IF;
2228:
2229: l_err_loc := 0;
2230:

Line 2269: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),

2265: l_err_loc := 500;
2266:
2267: IF (FND_LOG.LEVEL_EXCEPTION >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
2268: FND_LOG.string(FND_LOG.LEVEL_EXCEPTION,
2269: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),
2270: 'No Smart Forms found on the installation.');
2271: END IF;
2272: END;
2273:

Line 2275: ICX_CAT_UTIL_PVT.logProcEnd(g_pkg_name, l_api_name, 'End');

2271: END IF;
2272: END;
2273:
2274: IF (FND_LOG.LEVEL_PROCEDURE >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
2275: ICX_CAT_UTIL_PVT.logProcEnd(g_pkg_name, l_api_name, 'End');
2276: END IF;
2277:
2278: EXCEPTION
2279: WHEN OTHERS THEN

Line 2322: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name,

2318: END;
2319:
2320: IF (FND_LOG.LEVEL_EXCEPTION >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
2321: FND_LOG.string(FND_LOG.LEVEL_EXCEPTION,
2322: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name,
2323: 'exists_local_catalogs'),
2324: 'Checking if any catalogs exist (1=>TRUE) = '||l_exists_local_catalogs);
2325: END IF;
2326:

Line 2372: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, 'exists_item_sources'),

2368: END;
2369:
2370: IF (FND_LOG.LEVEL_EXCEPTION >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
2371: FND_LOG.string(FND_LOG.LEVEL_EXCEPTION,
2372: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, 'exists_item_sources'),
2373: 'Checking if any item sources exist (1=>TRUE) = '||l_exists_item_sources);
2374: END IF;
2375:
2376: l_err_loc := 300;

Line 2406: ICX_CAT_UTIL_PVT.logProcBegin(g_pkg_name, l_api_name, 'Start');

2402: l_err_loc PLS_INTEGER;
2403: BEGIN
2404:
2405: IF (FND_LOG.LEVEL_PROCEDURE >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
2406: ICX_CAT_UTIL_PVT.logProcBegin(g_pkg_name, l_api_name, 'Start');
2407: END IF;
2408:
2409: l_err_loc := 0;
2410:

Line 2425: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),

2421: g_store_security_flags(l_store_ids(i)) := l_security_flags(i);
2422:
2423: IF (FND_LOG.LEVEL_EXCEPTION >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
2424: FND_LOG.string(FND_LOG.LEVEL_EXCEPTION,
2425: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),
2426: 'For Store '||l_store_ids(i)||
2427: ', security flag='||l_security_flags(i));
2428: END IF;
2429:

Line 2435: ICX_CAT_UTIL_PVT.logProcEnd(g_pkg_name, l_api_name, 'End');

2431:
2432: l_err_loc := 200;
2433:
2434: IF (FND_LOG.LEVEL_PROCEDURE >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
2435: ICX_CAT_UTIL_PVT.logProcEnd(g_pkg_name, l_api_name, 'End');
2436: END IF;
2437:
2438: EXCEPTION
2439: WHEN OTHERS THEN

Line 2466: ICX_CAT_UTIL_PVT.logProcBegin(g_pkg_name, l_api_name, 'Start');

2462: l_err_loc PLS_INTEGER;
2463: BEGIN
2464:
2465: IF (FND_LOG.LEVEL_PROCEDURE >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
2466: ICX_CAT_UTIL_PVT.logProcBegin(g_pkg_name, l_api_name, 'Start');
2467: END IF;
2468:
2469: l_err_loc := 0;
2470:

Line 2488: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),

2484: g_catalog_supplier_flags(l_sources_ids(i)) := l_supplier_flags(i);
2485:
2486: IF (FND_LOG.LEVEL_EXCEPTION >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
2487: FND_LOG.string(FND_LOG.LEVEL_EXCEPTION,
2488: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),
2489: 'For Local Catalog '||l_sources_ids(i)||
2490: ', supplier flag='||l_supplier_flags(i));
2491: END IF;
2492:

Line 2498: ICX_CAT_UTIL_PVT.logProcEnd(g_pkg_name, l_api_name, 'End');

2494:
2495: l_err_loc := 200;
2496:
2497: IF (FND_LOG.LEVEL_PROCEDURE >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
2498: ICX_CAT_UTIL_PVT.logProcEnd(g_pkg_name, l_api_name, 'End');
2499: END IF;
2500:
2501: EXCEPTION
2502: WHEN OTHERS THEN

Line 2526: ICX_CAT_UTIL_PVT.logProcBegin(g_pkg_name, l_api_name, 'Start');

2522: l_err_loc PLS_INTEGER;
2523: BEGIN
2524:
2525: IF (FND_LOG.LEVEL_PROCEDURE >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
2526: ICX_CAT_UTIL_PVT.logProcBegin(g_pkg_name, l_api_name, 'Start');
2527: END IF;
2528:
2529: l_err_loc := 0;
2530:

Line 2554: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),

2550: l_err_loc := 300;
2551:
2552: IF (FND_LOG.LEVEL_EXCEPTION >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
2553: FND_LOG.string(FND_LOG.LEVEL_EXCEPTION,
2554: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),
2555: 'No downloaded exchange punchout catalogs found to migrate.');
2556: END IF;
2557:
2558: END;

Line 2561: ICX_CAT_UTIL_PVT.logProcEnd(g_pkg_name, l_api_name, 'End');

2557:
2558: END;
2559:
2560: IF (FND_LOG.LEVEL_PROCEDURE >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
2561: ICX_CAT_UTIL_PVT.logProcEnd(g_pkg_name, l_api_name, 'End');
2562: END IF;
2563:
2564: EXCEPTION
2565: WHEN OTHERS THEN

Line 2606: ICX_CAT_UTIL_PVT.logProcBegin(g_pkg_name, l_api_name, 'Start');

2602: l_err_loc PLS_INTEGER;
2603: BEGIN
2604:
2605: IF (FND_LOG.LEVEL_PROCEDURE >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
2606: ICX_CAT_UTIL_PVT.logProcBegin(g_pkg_name, l_api_name, 'Start');
2607: END IF;
2608:
2609: l_err_loc := 0;
2610:

Line 2625: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),

2621: ORDER BY sc.store_id;
2622:
2623: IF (FND_LOG.LEVEL_EXCEPTION >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
2624: FND_LOG.string(FND_LOG.LEVEL_EXCEPTION,
2625: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),
2626: 'Neither Local Catalogs nor Item Sources have been migrated.');
2627: END IF;
2628:
2629: -- else if item sources has not been migrated, select only them

Line 2643: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),

2639: ORDER BY sc.store_id;
2640:
2641: IF (FND_LOG.LEVEL_EXCEPTION >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
2642: FND_LOG.string(FND_LOG.LEVEL_EXCEPTION,
2643: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),
2644: 'Only Local Catalogs have been migrated, retrieving Item Sources.');
2645: END IF;
2646:
2647: -- else if local catalogs has not been migrated, select only local catalogs

Line 2661: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),

2657: ORDER BY sc.store_id;
2658:
2659: IF (FND_LOG.LEVEL_EXCEPTION >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
2660: FND_LOG.string(FND_LOG.LEVEL_EXCEPTION,
2661: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),
2662: 'Only Item Sources have been migrated, retrieving Local Catalogs.');
2663: END IF;
2664:
2665: END IF;

Line 2673: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),

2669: -- log out the contents to be migrated
2670: IF (FND_LOG.LEVEL_EXCEPTION >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
2671: FOR i IN 1..x_old_content_ids.COUNT LOOP
2672: FND_LOG.string(FND_LOG.LEVEL_EXCEPTION,
2673: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),
2674: i||'.old_content_id='||x_old_content_ids(i)||',type='
2675: ||x_content_types(i)||',store='||x_old_store_ids(i));
2676: END LOOP;
2677: END IF;

Line 2680: ICX_CAT_UTIL_PVT.logProcEnd(g_pkg_name, l_api_name, 'End');

2676: END LOOP;
2677: END IF;
2678:
2679: IF (FND_LOG.LEVEL_PROCEDURE >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
2680: ICX_CAT_UTIL_PVT.logProcEnd(g_pkg_name, l_api_name, 'End');
2681: END IF;
2682:
2683: EXCEPTION
2684: WHEN OTHERS THEN

Line 2715: ICX_CAT_UTIL_PVT.logProcBegin(g_pkg_name, l_api_name, 'Start');

2711: l_old_store_key NUMBER;
2712: BEGIN
2713:
2714: IF (FND_LOG.LEVEL_PROCEDURE >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
2715: ICX_CAT_UTIL_PVT.logProcBegin(g_pkg_name, l_api_name, 'Start');
2716: END IF;
2717:
2718: l_err_loc := 0;
2719:

Line 2770: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),

2766:
2767: WHILE (l_old_store_key IS NOT NULL) LOOP
2768:
2769: FND_LOG.string(FND_LOG.LEVEL_EXCEPTION,
2770: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),
2771: 'New Store '||g_stores_map(l_old_store_key)||
2772: ' created from Old Store '||l_old_store_key);
2773:
2774: l_old_store_key := g_stores_map.NEXT(l_old_store_key);

Line 2783: ICX_CAT_UTIL_PVT.logProcEnd(g_pkg_name, l_api_name, 'End');

2779:
2780: l_err_loc := 500;
2781:
2782: IF (FND_LOG.LEVEL_PROCEDURE >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
2783: ICX_CAT_UTIL_PVT.logProcEnd(g_pkg_name, l_api_name, 'End');
2784: END IF;
2785:
2786: EXCEPTION
2787: WHEN OTHERS THEN

Line 2818: ICX_CAT_UTIL_PVT.logProcBegin(g_pkg_name, l_api_name, 'Start');

2814: l_err_loc PLS_INTEGER;
2815: BEGIN
2816:
2817: IF (FND_LOG.LEVEL_PROCEDURE >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
2818: ICX_CAT_UTIL_PVT.logProcBegin(g_pkg_name, l_api_name, 'Start');
2819: END IF;
2820:
2821: l_err_loc := 0;
2822:

Line 2843: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),

2839: -- list all the content zones added to the new stores
2840: IF (FND_LOG.LEVEL_EXCEPTION >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
2841: FOR i IN 1..p_zone_ids.COUNT LOOP
2842: FND_LOG.string(FND_LOG.LEVEL_EXCEPTION,
2843: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),
2844: 'Adding Zone '||p_zone_ids(i)||' to R12 Store '||p_r12_store_id);
2845: END LOOP;
2846: END IF;
2847:

Line 2851: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),

2847:
2848: -- list the old IDs if statement-level logging is enabled
2849: IF (FND_LOG.LEVEL_STATEMENT >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
2850: FND_LOG.string(FND_LOG.LEVEL_STATEMENT,
2851: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),
2852: 'Old Source='||p_old_source_id||', Old Store='||p_old_store_id);
2853: END IF;
2854:
2855: l_err_loc := 200;

Line 2858: ICX_CAT_UTIL_PVT.logProcEnd(g_pkg_name, l_api_name, 'End');

2854:
2855: l_err_loc := 200;
2856:
2857: IF (FND_LOG.LEVEL_PROCEDURE >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
2858: ICX_CAT_UTIL_PVT.logProcEnd(g_pkg_name, l_api_name, 'End');
2859: END IF;
2860:
2861: EXCEPTION
2862: WHEN OTHERS THEN

Line 2893: ICX_CAT_UTIL_PVT.logProcBegin(g_pkg_name, l_api_name, 'Start');

2889: l_err_loc PLS_INTEGER;
2890: BEGIN
2891:
2892: IF (FND_LOG.LEVEL_PROCEDURE >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
2893: ICX_CAT_UTIL_PVT.logProcBegin(g_pkg_name, l_api_name, 'Start');
2894: END IF;
2895:
2896: l_err_loc := 0;
2897:

Line 2918: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),

2914: -- list all the content zones added to the new stores
2915: IF (FND_LOG.LEVEL_EXCEPTION >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
2916: FOR i IN 1..p_zone_ids.COUNT LOOP
2917: FND_LOG.string(FND_LOG.LEVEL_EXCEPTION,
2918: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),
2919: 'Adding Zone '||p_zone_ids(i)||' to R12 Store '||p_r12_store_ids(i));
2920: END LOOP;
2921: END IF;
2922:

Line 2927: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),

2923: -- list the old IDs if statement-level logging is enabled
2924: IF (FND_LOG.LEVEL_STATEMENT >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
2925: FOR i IN 1..p_old_source_ids.COUNT LOOP
2926: FND_LOG.string(FND_LOG.LEVEL_STATEMENT,
2927: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),
2928: 'Old Source='||p_old_source_ids(i)||', Old Store='||p_old_store_ids(i));
2929: END LOOP;
2930: END IF;
2931:

Line 2935: ICX_CAT_UTIL_PVT.logProcEnd(g_pkg_name, l_api_name, 'End');

2931:
2932: l_err_loc := 200;
2933:
2934: IF (FND_LOG.LEVEL_PROCEDURE >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
2935: ICX_CAT_UTIL_PVT.logProcEnd(g_pkg_name, l_api_name, 'End');
2936: END IF;
2937:
2938: EXCEPTION
2939: WHEN OTHERS THEN

Line 2972: ICX_CAT_UTIL_PVT.logProcBegin(g_pkg_name, l_api_name, 'Start');

2968: l_err_loc PLS_INTEGER;
2969: BEGIN
2970:
2971: IF (FND_LOG.LEVEL_PROCEDURE >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
2972: ICX_CAT_UTIL_PVT.logProcBegin(g_pkg_name, l_api_name, 'Start');
2973: END IF;
2974:
2975: l_err_loc := 0;
2976:

Line 2996: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),

2992: -- list all the smart forms migrated to the new stores
2993: IF (FND_LOG.LEVEL_EXCEPTION >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
2994: FOR i IN 1..p_smart_form_ids.COUNT LOOP
2995: FND_LOG.string(FND_LOG.LEVEL_EXCEPTION,
2996: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),
2997: 'Moving Smart Form '||p_smart_form_ids(i)||' from Old Store '||
2998: p_old_store_ids(i)||' to R12 Store '||p_r12_store_ids(i));
2999: END LOOP;
3000: END IF;

Line 3005: ICX_CAT_UTIL_PVT.logProcEnd(g_pkg_name, l_api_name, 'End');

3001:
3002: l_err_loc := 200;
3003:
3004: IF (FND_LOG.LEVEL_PROCEDURE >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
3005: ICX_CAT_UTIL_PVT.logProcEnd(g_pkg_name, l_api_name, 'End');
3006: END IF;
3007:
3008: EXCEPTION
3009: WHEN OTHERS THEN

Line 3039: ICX_CAT_UTIL_PVT.logProcBegin(g_pkg_name, l_api_name,

3035: l_err_loc PLS_INTEGER;
3036: BEGIN
3037:
3038: IF (FND_LOG.LEVEL_PROCEDURE >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
3039: ICX_CAT_UTIL_PVT.logProcBegin(g_pkg_name, l_api_name,
3040: 'p_num_zones='||p_num_zones);
3041: END IF;
3042:
3043: l_err_loc := 0;

Line 3063: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),

3059:
3060: IF (FND_LOG.LEVEL_STATEMENT >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
3061: FOR i IN 1..l_new_zone_ids.COUNT LOOP
3062: FND_LOG.string(FND_LOG.LEVEL_STATEMENT,
3063: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),
3064: 'New Zone ID '||l_new_zone_ids(i)||' allocated.');
3065: END LOOP;
3066: END IF;
3067:

Line 3071: ICX_CAT_UTIL_PVT.logProcEnd(g_pkg_name, l_api_name, 'End');

3067:
3068: l_err_loc := 300;
3069:
3070: IF (FND_LOG.LEVEL_PROCEDURE >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
3071: ICX_CAT_UTIL_PVT.logProcEnd(g_pkg_name, l_api_name, 'End');
3072: END IF;
3073:
3074: RETURN l_new_zone_ids;
3075:

Line 3133: ICX_CAT_UTIL_PVT.logProcBegin(g_pkg_name, l_api_name, 'Start');

3129: l_err_loc PLS_INTEGER;
3130: BEGIN
3131:
3132: IF (FND_LOG.LEVEL_PROCEDURE >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
3133: ICX_CAT_UTIL_PVT.logProcBegin(g_pkg_name, l_api_name, 'Start');
3134: END IF;
3135:
3136: l_err_loc := 0;
3137:

Line 3167: ICX_CAT_UTIL_PVT.logProcEnd(g_pkg_name, l_api_name, 'End');

3163:
3164: l_err_loc := 300;
3165:
3166: IF (FND_LOG.LEVEL_PROCEDURE >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
3167: ICX_CAT_UTIL_PVT.logProcEnd(g_pkg_name, l_api_name, 'End');
3168: END IF;
3169:
3170: EXCEPTION
3171: WHEN OTHERS THEN

Line 3220: ICX_CAT_UTIL_PVT.logProcBegin(g_pkg_name, l_api_name, 'Start(Generic)');

3216: l_err_loc PLS_INTEGER;
3217: BEGIN
3218:
3219: IF (FND_LOG.LEVEL_PROCEDURE >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
3220: ICX_CAT_UTIL_PVT.logProcBegin(g_pkg_name, l_api_name, 'Start(Generic)');
3221: END IF;
3222:
3223: l_err_loc := 0;
3224:

Line 3275: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),

3271: -- log out all the new zones created
3272: IF (FND_LOG.LEVEL_EXCEPTION >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
3273: FOR i IN 1..p_new_zone_ids.COUNT LOOP
3274: FND_LOG.string(FND_LOG.LEVEL_EXCEPTION,
3275: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),
3276: 'Zone '||p_new_zone_ids(i)||' created from Local Catalog '||
3277: p_catalog_ids(i)||' with security flag='||p_security_flags(i)||
3278: ', supplier flag='||p_supplier_flags(i)||
3279: ', category flag='||p_category_flag);

Line 3284: ICX_CAT_UTIL_PVT.logProcEnd(g_pkg_name, l_api_name, 'End(Generic)');

3280: END LOOP;
3281: END IF;
3282:
3283: IF (FND_LOG.LEVEL_PROCEDURE >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
3284: ICX_CAT_UTIL_PVT.logProcEnd(g_pkg_name, l_api_name, 'End(Generic)');
3285: END IF;
3286:
3287: EXCEPTION
3288: WHEN OTHERS THEN

Line 3330: ICX_CAT_UTIL_PVT.logProcBegin(g_pkg_name, l_api_name, 'Start');

3326: l_err_loc PLS_INTEGER;
3327: BEGIN
3328:
3329: IF (FND_LOG.LEVEL_PROCEDURE >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
3330: ICX_CAT_UTIL_PVT.logProcBegin(g_pkg_name, l_api_name, 'Start');
3331: END IF;
3332:
3333: l_err_loc := 0;
3334:

Line 3372: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),

3368: -- log out all the new zones created
3369: IF (FND_LOG.LEVEL_EXCEPTION >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
3370: FOR i IN 1..p_new_zone_ids.COUNT LOOP
3371: FND_LOG.string(FND_LOG.LEVEL_EXCEPTION,
3372: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),
3373: 'Special All-Local-Content Zone '||p_new_zone_ids(i)||' created.');
3374: END LOOP;
3375: END IF;
3376:

Line 3378: ICX_CAT_UTIL_PVT.logProcEnd(g_pkg_name, l_api_name, 'End');

3374: END LOOP;
3375: END IF;
3376:
3377: IF (FND_LOG.LEVEL_PROCEDURE >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
3378: ICX_CAT_UTIL_PVT.logProcEnd(g_pkg_name, l_api_name, 'End');
3379: END IF;
3380:
3381: EXCEPTION
3382: WHEN OTHERS THEN

Line 3419: ICX_CAT_UTIL_PVT.logProcBegin(g_pkg_name, l_api_name, 'Start');

3415: l_err_loc PLS_INTEGER;
3416: BEGIN
3417:
3418: IF (FND_LOG.LEVEL_PROCEDURE >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
3419: ICX_CAT_UTIL_PVT.logProcBegin(g_pkg_name, l_api_name, 'Start');
3420: END IF;
3421:
3422: l_err_loc := 0;
3423:

Line 3470: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),

3466: -- for statement-level logging, print out values inserted
3467: IF (FND_LOG.LEVEL_STATEMENT >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
3468: FOR i IN 1..l_zones_to_insert.COUNT LOOP
3469: FND_LOG.string(FND_LOG.LEVEL_STATEMENT,
3470: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),
3471: 'Zone '||l_zones_to_insert(i)||' secured by Category '||
3472: l_categories_to_insert(i));
3473: END LOOP;
3474: END IF;

Line 3479: ICX_CAT_UTIL_PVT.logProcEnd(g_pkg_name, l_api_name, 'End');

3475:
3476: l_err_loc := 500;
3477:
3478: IF (FND_LOG.LEVEL_PROCEDURE >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
3479: ICX_CAT_UTIL_PVT.logProcEnd(g_pkg_name, l_api_name, 'End');
3480: END IF;
3481:
3482: EXCEPTION
3483: WHEN OTHERS THEN

Line 3528: ICX_CAT_UTIL_PVT.logProcBegin(g_pkg_name, l_api_name, 'Start');

3524: l_err_loc PLS_INTEGER;
3525: BEGIN
3526:
3527: IF (FND_LOG.LEVEL_PROCEDURE >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
3528: ICX_CAT_UTIL_PVT.logProcBegin(g_pkg_name, l_api_name, 'Start');
3529: END IF;
3530:
3531: l_err_loc := 0;
3532:

Line 3557: ICX_CAT_UTIL_PVT.logProcEnd(g_pkg_name, l_api_name, 'End');

3553:
3554: l_err_loc := 300;
3555:
3556: IF (FND_LOG.LEVEL_PROCEDURE >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
3557: ICX_CAT_UTIL_PVT.logProcEnd(g_pkg_name, l_api_name, 'End');
3558: END IF;
3559:
3560: EXCEPTION
3561: WHEN OTHERS THEN

Line 3600: ICX_CAT_UTIL_PVT.logProcBegin(g_pkg_name, l_api_name, 'Start(Generic)');

3596: l_err_loc PLS_INTEGER;
3597: BEGIN
3598:
3599: IF (FND_LOG.LEVEL_PROCEDURE >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
3600: ICX_CAT_UTIL_PVT.logProcBegin(g_pkg_name, l_api_name, 'Start(Generic)');
3601: END IF;
3602:
3603: l_err_loc := 0;
3604:

Line 3715: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),

3711: l_err_loc := 600;
3712:
3713: IF (FND_LOG.LEVEL_EXCEPTION >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
3714: FND_LOG.string(FND_LOG.LEVEL_EXCEPTION,
3715: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),
3716: 'For exchange item source '||p_item_source_ids(i)||
3717: ', new content zone ID = '||p_new_zone_ids(i));
3718: END IF;
3719:

Line 3728: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),

3724: -- log out all the new zones created
3725: IF (FND_LOG.LEVEL_EXCEPTION >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
3726: FOR i IN 1..p_new_zone_ids.COUNT LOOP
3727: FND_LOG.string(FND_LOG.LEVEL_EXCEPTION,
3728: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),
3729: 'Zone '||p_new_zone_ids(i)||' created from Item Source '||
3730: p_item_source_ids(i)||' with security flag ='||p_security_flags(i));
3731: END LOOP;
3732: END IF;

Line 3737: ICX_CAT_UTIL_PVT.logProcEnd(g_pkg_name, l_api_name, 'End(Generic)');

3733:
3734: l_err_loc := 700;
3735:
3736: IF (FND_LOG.LEVEL_PROCEDURE >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
3737: ICX_CAT_UTIL_PVT.logProcEnd(g_pkg_name, l_api_name, 'End(Generic)');
3738: END IF;
3739:
3740: EXCEPTION
3741: WHEN OTHERS THEN

Line 3778: ICX_CAT_UTIL_PVT.logProcBegin(g_pkg_name, l_api_name, 'Start');

3774: l_err_loc PLS_INTEGER;
3775: BEGIN
3776:
3777: IF (FND_LOG.LEVEL_PROCEDURE >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
3778: ICX_CAT_UTIL_PVT.logProcBegin(g_pkg_name, l_api_name, 'Start');
3779: END IF;
3780:
3781: l_err_loc := 0;
3782:

Line 3809: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),

3805:
3806: -- this shouldn't happen (bad data), so log out an exception and continue
3807: IF (FND_LOG.LEVEL_EXCEPTION >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
3808: FND_LOG.string(FND_LOG.LEVEL_EXCEPTION,
3809: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),
3810: 'Could not find a mapping for the old operator ID = '||
3811: l_old_operator_ids(i));
3812: END IF;
3813: l_err_loc := 400;

Line 3827: ICX_CAT_UTIL_PVT.logProcEnd(g_pkg_name, l_api_name, 'End');

3823: WHERE parent_zone_id = l_old_operator_ids(i);
3824: l_err_loc := 200;
3825:
3826: IF (FND_LOG.LEVEL_PROCEDURE >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
3827: ICX_CAT_UTIL_PVT.logProcEnd(g_pkg_name, l_api_name, 'End');
3828: END IF;
3829:
3830: EXCEPTION
3831: WHEN OTHERS THEN

Line 3872: ICX_CAT_UTIL_PVT.logProcBegin(g_pkg_name, l_api_name, 'Start');

3868: l_err_loc PLS_INTEGER;
3869: BEGIN
3870:
3871: IF (FND_LOG.LEVEL_PROCEDURE >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
3872: ICX_CAT_UTIL_PVT.logProcBegin(g_pkg_name, l_api_name, 'Start');
3873: END IF;
3874:
3875: l_err_loc := 0;
3876:

Line 3892: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),

3888:
3889: -- note how many pairs secured
3890: IF (FND_LOG.LEVEL_EXCEPTION >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
3891: FND_LOG.string(FND_LOG.LEVEL_EXCEPTION,
3892: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),
3893: 'Securing Zones by Operating Units, p_new_zone_ids.COUNT='
3894: ||p_new_zone_ids.COUNT);
3895: END IF;
3896:

Line 3901: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),

3897: -- for statement-level logging, print out all tuples
3898: IF (FND_LOG.LEVEL_STATEMENT >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
3899: FOR i IN 1..p_new_zone_ids.COUNT LOOP
3900: FND_LOG.string(FND_LOG.LEVEL_STATEMENT,
3901: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),
3902: 'Zone '||p_new_zone_ids(i)||' secured by OUs from Store '||
3903: p_old_store_ids(i)||' with security flag='||p_security_flags(i));
3904: END LOOP;
3905: END IF;

Line 3910: ICX_CAT_UTIL_PVT.logProcEnd(g_pkg_name, l_api_name, 'End');

3906:
3907: l_err_loc := 100;
3908:
3909: IF (FND_LOG.LEVEL_PROCEDURE >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
3910: ICX_CAT_UTIL_PVT.logProcEnd(g_pkg_name, l_api_name, 'End');
3911: END IF;
3912:
3913: EXCEPTION
3914: WHEN OTHERS THEN

Line 3942: ICX_CAT_UTIL_PVT.logProcBegin(g_pkg_name, l_api_name, 'Start');

3938: l_err_loc PLS_INTEGER;
3939: BEGIN
3940:
3941: IF (FND_LOG.LEVEL_PROCEDURE >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
3942: ICX_CAT_UTIL_PVT.logProcBegin(g_pkg_name, l_api_name, 'Start');
3943: END IF;
3944:
3945: l_err_loc := 0;
3946:

Line 3959: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),

3955:
3956: -- note how many pairs secured
3957: IF (FND_LOG.LEVEL_EXCEPTION >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
3958: FND_LOG.string(FND_LOG.LEVEL_EXCEPTION,
3959: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),
3960: 'Securing Zones by Responsibilities, p_new_zone_ids.COUNT='
3961: ||p_new_zone_ids.COUNT);
3962: END IF;
3963:

Line 3968: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),

3964: -- for statement-level logging, print out all pairs
3965: IF (FND_LOG.LEVEL_STATEMENT >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
3966: FOR i IN 1..p_new_zone_ids.COUNT LOOP
3967: FND_LOG.string(FND_LOG.LEVEL_STATEMENT,
3968: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),
3969: 'Zone '||p_new_zone_ids(i)||' secured by resp '||p_resp_ids(i));
3970: END LOOP;
3971: END IF;
3972:

Line 3976: ICX_CAT_UTIL_PVT.logProcEnd(g_pkg_name, l_api_name, 'End');

3972:
3973: l_err_loc := 100;
3974:
3975: IF (FND_LOG.LEVEL_PROCEDURE >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
3976: ICX_CAT_UTIL_PVT.logProcEnd(g_pkg_name, l_api_name, 'End');
3977: END IF;
3978:
3979: EXCEPTION
3980: WHEN OTHERS THEN

Line 4008: ICX_CAT_UTIL_PVT.logProcBegin(g_pkg_name, l_api_name,

4004: l_err_loc PLS_INTEGER;
4005: BEGIN
4006:
4007: IF (FND_LOG.LEVEL_PROCEDURE >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
4008: ICX_CAT_UTIL_PVT.logProcBegin(g_pkg_name, l_api_name,
4009: 'p_new_zone_id='||p_new_zone_id||',p_resp_ids.COUNT='||p_resp_ids.COUNT);
4010: END IF;
4011:
4012: l_err_loc := 0;

Line 4029: ICX_CAT_UTIL_PVT.logProcEnd(g_pkg_name, l_api_name, 'End');

4025: -- after populating the zones lists, leverage the generic method
4026: secure_zones_by_resps(l_new_zone_ids, p_resp_ids);
4027:
4028: IF (FND_LOG.LEVEL_PROCEDURE >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
4029: ICX_CAT_UTIL_PVT.logProcEnd(g_pkg_name, l_api_name, 'End');
4030: END IF;
4031:
4032: EXCEPTION
4033: WHEN OTHERS THEN

Line 4082: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),

4078: l_err_loc := 200;
4079:
4080: IF (FND_LOG.LEVEL_STATEMENT >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
4081: FND_LOG.string(FND_LOG.LEVEL_STATEMENT,
4082: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),
4083: 'Found existing list for Item Source '||l_item_source_ids(j));
4084: END IF;
4085:
4086: ELSE

Line 4093: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),

4089: l_err_loc := 300;
4090:
4091: IF (FND_LOG.LEVEL_STATEMENT >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
4092: FND_LOG.string(FND_LOG.LEVEL_STATEMENT,
4093: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),
4094: 'A new list created for Item Source '||l_item_source_ids(j));
4095: END IF;
4096:
4097: END IF;

Line 4105: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),

4101: g_item_sources_to_resp_map(l_item_source_ids(j)) := l_resp_list_ids;
4102:
4103: IF (FND_LOG.LEVEL_STATEMENT >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
4104: FND_LOG.string(FND_LOG.LEVEL_STATEMENT,
4105: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),
4106: 'Appending resp '||g_resp_with_isrc_realms(i));
4107: END IF;
4108:
4109: l_err_loc := 400;

Line 4126: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),

4122: l_resp_list_ids := g_item_sources_to_resp_map(l_isrc_key);
4123:
4124: FOR i IN 1..l_resp_list_ids.COUNT LOOP
4125: FND_LOG.string(FND_LOG.LEVEL_EXCEPTION,
4126: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),
4127: 'Item Source '||l_isrc_key||' accessible via realms to resp '||
4128: l_resp_list_ids(i));
4129: END LOOP;
4130:

Line 4173: ICX_CAT_UTIL_PVT.logProcBegin(g_pkg_name, l_api_name,

4169: l_err_loc PLS_INTEGER;
4170: BEGIN
4171:
4172: IF (FND_LOG.LEVEL_PROCEDURE >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
4173: ICX_CAT_UTIL_PVT.logProcBegin(g_pkg_name, l_api_name,
4174: 'p_resp_id='||p_resp_id);
4175: END IF;
4176:
4177: l_err_loc := 0;

Line 4187: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),

4183:
4184: -- for statement-level logging, note that the values were cached
4185: IF (FND_LOG.LEVEL_STATEMENT >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
4186: FND_LOG.string(FND_LOG.LEVEL_STATEMENT,
4187: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),
4188: 'Category realm values for resp '||p_resp_id||
4189: ' was already queried, returning cached values.');
4190: END IF;
4191:

Line 4205: ICX_CAT_UTIL_PVT.logProcEnd(g_pkg_name, l_api_name, 'End');

4201:
4202: END IF;
4203:
4204: IF (FND_LOG.LEVEL_PROCEDURE >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
4205: ICX_CAT_UTIL_PVT.logProcEnd(g_pkg_name, l_api_name, 'End');
4206: END IF;
4207:
4208: RETURN l_realm_values;
4209:

Line 4268: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),

4264:
4265: -- note how many realm values were found
4266: IF (FND_LOG.LEVEL_EXCEPTION >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
4267: FND_LOG.string(FND_LOG.LEVEL_EXCEPTION,
4268: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),
4269: p_realm_type||' realm values for resp '||p_resp_id||', count = '||
4270: l_realm_values.COUNT);
4271: END IF;
4272:

Line 4279: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),

4275: -- for statement-level logging, log all values
4276: IF (FND_LOG.LEVEL_STATEMENT >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
4277: FOR i IN 1..l_realm_values.COUNT LOOP
4278: FND_LOG.string(FND_LOG.LEVEL_STATEMENT,
4279: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),
4280: i||'.'||l_realm_values(i));
4281: END LOOP;
4282: END IF;
4283:

Line 4348: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),

4344:
4345: -- note how many responsibilities without realms were found
4346: IF (FND_LOG.LEVEL_EXCEPTION >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
4347: FND_LOG.string(FND_LOG.LEVEL_EXCEPTION,
4348: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),
4349: 'Resps after filtering out those without Category values, count = '||
4350: l_resp_with_realm_values_ids.COUNT);
4351: END IF;
4352:

Line 4359: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),

4355: -- for statement-level logging, log all responsibilties
4356: IF (FND_LOG.LEVEL_STATEMENT >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
4357: FOR i IN 1..l_resp_with_realm_values_ids.COUNT LOOP
4358: FND_LOG.string(FND_LOG.LEVEL_STATEMENT,
4359: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),
4360: i||'.'||l_resp_with_realm_values_ids(i));
4361: END LOOP;
4362: END IF;
4363:

Line 4397: ICX_CAT_UTIL_PVT.logProcBegin(g_pkg_name, l_api_name,

4393: l_err_loc PLS_INTEGER;
4394: BEGIN
4395:
4396: IF (FND_LOG.LEVEL_PROCEDURE >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
4397: ICX_CAT_UTIL_PVT.logProcBegin(g_pkg_name, l_api_name,
4398: 'p_realm_type='||p_realm_type);
4399: END IF;
4400:
4401: l_err_loc := 0;

Line 4431: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),

4427:
4428: -- note how many responsibilities with realms were found
4429: IF (FND_LOG.LEVEL_EXCEPTION >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
4430: FND_LOG.string(FND_LOG.LEVEL_EXCEPTION,
4431: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),
4432: 'All Resps With '||p_realm_type||' Realms, count = '||
4433: l_all_resp_with_realms_ids.COUNT);
4434: END IF;
4435:

Line 4440: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),

4436: -- for statement-level logging, log all responsibilties
4437: IF (FND_LOG.LEVEL_STATEMENT >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
4438: FOR i IN 1..l_all_resp_with_realms_ids.COUNT LOOP
4439: FND_LOG.string(FND_LOG.LEVEL_STATEMENT,
4440: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),
4441: i||'.'||l_all_resp_with_realms_ids(i));
4442: END LOOP;
4443: END IF;
4444:

Line 4448: ICX_CAT_UTIL_PVT.logProcEnd(g_pkg_name, l_api_name, 'End');

4444:
4445: l_err_loc := 100;
4446:
4447: IF (FND_LOG.LEVEL_PROCEDURE >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
4448: ICX_CAT_UTIL_PVT.logProcEnd(g_pkg_name, l_api_name, 'End');
4449: END IF;
4450:
4451: RETURN l_all_resp_with_realms_ids;
4452:

Line 4481: ICX_CAT_UTIL_PVT.logProcBegin(g_pkg_name, l_api_name,

4477: l_err_loc PLS_INTEGER;
4478: BEGIN
4479:
4480: IF (FND_LOG.LEVEL_PROCEDURE >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
4481: ICX_CAT_UTIL_PVT.logProcBegin(g_pkg_name, l_api_name,
4482: 'p_realm_type='||p_realm_type);
4483: END IF;
4484:
4485: l_err_loc := 0;

Line 4518: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),

4514:
4515: -- note how many responsibilities without realms were found
4516: IF (FND_LOG.LEVEL_EXCEPTION >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
4517: FND_LOG.string(FND_LOG.LEVEL_EXCEPTION,
4518: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),
4519: 'All Resps Without '||p_realm_type||' Realms, count = '||
4520: l_all_resp_without_realms_ids.COUNT);
4521: END IF;
4522:

Line 4527: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),

4523: -- for statement-level logging, log all responsibilties
4524: IF (FND_LOG.LEVEL_STATEMENT >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
4525: FOR i IN 1..l_all_resp_without_realms_ids.COUNT LOOP
4526: FND_LOG.string(FND_LOG.LEVEL_STATEMENT,
4527: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),
4528: i||'.'||l_all_resp_without_realms_ids(i));
4529: END LOOP;
4530: END IF;
4531:

Line 4535: ICX_CAT_UTIL_PVT.logProcEnd(g_pkg_name, l_api_name, 'End');

4531:
4532: l_err_loc := 100;
4533:
4534: IF (FND_LOG.LEVEL_PROCEDURE >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
4535: ICX_CAT_UTIL_PVT.logProcEnd(g_pkg_name, l_api_name, 'End');
4536: END IF;
4537:
4538: RETURN l_all_resp_without_realms_ids;
4539:

Line 4576: ICX_CAT_UTIL_PVT.logProcBegin(g_pkg_name, l_api_name,

4572: l_err_loc PLS_INTEGER;
4573: BEGIN
4574:
4575: IF (FND_LOG.LEVEL_PROCEDURE >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
4576: ICX_CAT_UTIL_PVT.logProcBegin(g_pkg_name, l_api_name,
4577: 'p_realm_type='||p_realm_type||',p_old_store_id='||p_old_store_id);
4578: END IF;
4579:
4580: l_err_loc := 0;

Line 4647: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),

4643: -- for statement-level logging, log all responsibilties
4644: IF (FND_LOG.LEVEL_STATEMENT >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
4645: FOR i IN 1..l_resp_with_realms_ids.COUNT LOOP
4646: FND_LOG.string(FND_LOG.LEVEL_STATEMENT,
4647: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),
4648: i||'.'||l_resp_with_realms_ids(i));
4649: END LOOP;
4650: END IF;
4651:

Line 4657: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),

4653:
4654: -- note how many responsibilities without realms were found
4655: IF (FND_LOG.LEVEL_EXCEPTION >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
4656: FND_LOG.string(FND_LOG.LEVEL_EXCEPTION,
4657: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),
4658: 'Resps With '||p_realm_type||' Realms for Store '||p_old_store_id||
4659: ', count = '||l_resp_with_realms_ids.COUNT);
4660: END IF;
4661:

Line 4665: ICX_CAT_UTIL_PVT.logProcEnd(g_pkg_name, l_api_name, 'End');

4661:
4662: l_err_loc := 500;
4663:
4664: IF (FND_LOG.LEVEL_PROCEDURE >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
4665: ICX_CAT_UTIL_PVT.logProcEnd(g_pkg_name, l_api_name, 'End');
4666: END IF;
4667:
4668: RETURN l_resp_with_realms_ids;
4669:

Line 4706: ICX_CAT_UTIL_PVT.logProcBegin(g_pkg_name, l_api_name,

4702: l_err_loc PLS_INTEGER;
4703: BEGIN
4704:
4705: IF (FND_LOG.LEVEL_PROCEDURE >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
4706: ICX_CAT_UTIL_PVT.logProcBegin(g_pkg_name, l_api_name,
4707: 'p_realm_type='||p_realm_type||',p_old_store_id='||p_old_store_id);
4708: END IF;
4709:
4710: l_err_loc := 0;

Line 4779: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),

4775: -- for statement-level logging, log all responsibilties
4776: IF (FND_LOG.LEVEL_STATEMENT >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
4777: FOR i IN 1..l_resp_without_realms_ids.COUNT LOOP
4778: FND_LOG.string(FND_LOG.LEVEL_STATEMENT,
4779: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),
4780: i||'.'||l_resp_without_realms_ids(i));
4781: END LOOP;
4782: END IF;
4783:

Line 4789: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),

4785:
4786: -- note how many responsibilities without realms were found
4787: IF (FND_LOG.LEVEL_EXCEPTION >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
4788: FND_LOG.string(FND_LOG.LEVEL_EXCEPTION,
4789: ICX_CAT_UTIL_PVT.getModuleNameForDebug(g_pkg_name, l_api_name),
4790: 'Resps Without '||p_realm_type||' Realms for Store '||p_old_store_id||
4791: ', count = '||l_resp_without_realms_ids.COUNT);
4792: END IF;
4793:

Line 4797: ICX_CAT_UTIL_PVT.logProcEnd(g_pkg_name, l_api_name, 'End');

4793:
4794: l_err_loc := 500;
4795:
4796: IF (FND_LOG.LEVEL_PROCEDURE >= FND_LOG.G_CURRENT_RUNTIME_LEVEL) THEN
4797: ICX_CAT_UTIL_PVT.logProcEnd(g_pkg_name, l_api_name, 'End');
4798: END IF;
4799:
4800: RETURN l_resp_without_realms_ids;
4801: