APPS.MSC_CONFIG_FF dependencies on FND_FLEX_DSC_API

Line 33: fnd_flex_dsc_api.debug_on;

29: msgbuf VARCHAR2(2000);
30:
31: Begin
32:
33: fnd_flex_dsc_api.debug_on;
34: fnd_flex_dsc_api.set_session_mode('seed_data');
35:
36: IF item_attr1 IS NOT NULL THEN
37:

Line 34: fnd_flex_dsc_api.set_session_mode('seed_data');

30:
31: Begin
32:
33: fnd_flex_dsc_api.debug_on;
34: fnd_flex_dsc_api.set_session_mode('seed_data');
35:
36: IF item_attr1 IS NOT NULL THEN
37:
38: fnd_flex_dsc_api.enable_context('INV',

Line 38: fnd_flex_dsc_api.enable_context('INV',

34: fnd_flex_dsc_api.set_session_mode('seed_data');
35:
36: IF item_attr1 IS NOT NULL THEN
37:
38: fnd_flex_dsc_api.enable_context('INV',
39: 'MTL_SYSTEM_ITEMS',
40: 'Global Data Elements',
41: TRUE);
42:

Line 43: IF fnd_flex_dsc_api.segment_exists(

39: 'MTL_SYSTEM_ITEMS',
40: 'Global Data Elements',
41: TRUE);
42:
43: IF fnd_flex_dsc_api.segment_exists(
44: p_appl_short_name=>'INV',
45: p_flexfield_name=>'MTL_SYSTEM_ITEMS',
46: p_context_code=>'Global Data Elements',
47: p_segment_name=>'Service Level') = TRUE THEN

Line 57: fnd_flex_dsc_api.create_segment(

53: LOG_MESSAGE(msgbuf);
54:
55: ELSE
56:
57: fnd_flex_dsc_api.create_segment(
58: appl_short_name => 'INV',
59: flexfield_name => 'MTL_SYSTEM_ITEMS',
60: context_name => 'Global Data Elements',
61: name => 'Service Level',

Line 87: fnd_flex_dsc_api.enable_context('INV',

83:
84:
85: IF org_attr1 IS NOT NULL THEN
86:
87: fnd_flex_dsc_api.enable_context('INV',
88: 'MTL_PARAMETERS',
89: 'Global Data Elements',
90: TRUE);
91:

Line 92: IF fnd_flex_dsc_api.segment_exists(

88: 'MTL_PARAMETERS',
89: 'Global Data Elements',
90: TRUE);
91:
92: IF fnd_flex_dsc_api.segment_exists(
93: p_appl_short_name=>'INV',
94: p_flexfield_name=>'MTL_PARAMETERS',
95: p_context_code=>'Global Data Elements',
96: p_segment_name=>'Service Level') = TRUE THEN

Line 106: fnd_flex_dsc_api.create_segment(

102: LOG_MESSAGE(msgbuf);
103:
104: ELSE
105:
106: fnd_flex_dsc_api.create_segment(
107: appl_short_name => 'INV',
108: flexfield_name => 'MTL_PARAMETERS',
109: context_name => 'Global Data Elements',
110: name => 'Service Level',

Line 136: fnd_flex_dsc_api.enable_context('AR',

132: END IF; -- org_attr1 is not null
133:
134: IF cust_attr1 IS NOT NULL THEN
135:
136: fnd_flex_dsc_api.enable_context('AR',
137: 'RA_CUSTOMERS_HZ',
138: 'Global Data Elements',
139: TRUE);
140:

Line 141: IF fnd_flex_dsc_api.segment_exists(

137: 'RA_CUSTOMERS_HZ',
138: 'Global Data Elements',
139: TRUE);
140:
141: IF fnd_flex_dsc_api.segment_exists(
142: p_appl_short_name=>'AR',
143: p_flexfield_name=>'RA_CUSTOMERS_HZ',
144: p_context_code=>'Global Data Elements',
145: p_segment_name=>'Service Level') = TRUE THEN

Line 155: fnd_flex_dsc_api.create_segment(

151: LOG_MESSAGE(msgbuf);
152:
153: ELSE
154:
155: fnd_flex_dsc_api.create_segment(
156: appl_short_name => 'AR',
157: flexfield_name => 'RA_CUSTOMERS_HZ',
158: context_name => 'Global Data Elements',
159: name => 'Service Level',

Line 217: if (fnd_flex_dsc_api.message is null) then

213: substr(fnd_message.get,1,240);
214: retcode := 2;
215: WHEN OTHERS THEN
216: rollback;
217: if (fnd_flex_dsc_api.message is null) then
218: errbuf := 'Sql Error:' || to_char(sqlcode);
219: else
220: errbuf := fnd_flex_dsc_api.message;
221: end if;

Line 220: errbuf := fnd_flex_dsc_api.message;

216: rollback;
217: if (fnd_flex_dsc_api.message is null) then
218: errbuf := 'Sql Error:' || to_char(sqlcode);
219: else
220: errbuf := fnd_flex_dsc_api.message;
221: end if;
222: retcode := 2; -- failure
223:
224: END Configure_forecast_flex;

Line 257: fnd_flex_dsc_api.debug_on;

253: ------------------------------
254:
255: BEGIN
256:
257: fnd_flex_dsc_api.debug_on;
258: fnd_flex_dsc_api.set_session_mode('seed_data');
259:
260: IF item_attr1 is NOT NULL THEN
261:

Line 258: fnd_flex_dsc_api.set_session_mode('seed_data');

254:
255: BEGIN
256:
257: fnd_flex_dsc_api.debug_on;
258: fnd_flex_dsc_api.set_session_mode('seed_data');
259:
260: IF item_attr1 is NOT NULL THEN
261:
262: fnd_flex_dsc_api.enable_context('INV',

Line 262: fnd_flex_dsc_api.enable_context('INV',

258: fnd_flex_dsc_api.set_session_mode('seed_data');
259:
260: IF item_attr1 is NOT NULL THEN
261:
262: fnd_flex_dsc_api.enable_context('INV',
263: 'MTL_SYSTEM_ITEMS',
264: 'Global Data Elements',
265: TRUE);
266: IF fnd_flex_dsc_api.is_column_used(

Line 266: IF fnd_flex_dsc_api.is_column_used(

262: fnd_flex_dsc_api.enable_context('INV',
263: 'MTL_SYSTEM_ITEMS',
264: 'Global Data Elements',
265: TRUE);
266: IF fnd_flex_dsc_api.is_column_used(
267: p_application_id => '401',
268: p_table_name => 'MTL_SYSTEM_ITEMS_B',
269: p_column_name => 'ATTRIBUTE'||to_char(item_attr1),
270: x_message => msgbuf) = TRUE THEN

Line 279: ELSIF fnd_flex_dsc_api.segment_exists(

275: FND_MESSAGE.set_token('TABLE','MTL_SYSTEM_ITEMS');
276: msgbuf := FND_MESSAGE.get;
277: LOG_MESSAGE(msgbuf);
278:
279: ELSIF fnd_flex_dsc_api.segment_exists(
280: p_appl_short_name=>'INV',
281: p_flexfield_name=>'MTL_SYSTEM_ITEMS',
282: p_context_code=>'Global Data Elements',
283: p_segment_name=>'Late Demands Penalty') = TRUE THEN

Line 293: fnd_flex_dsc_api.create_segment(

289: LOG_MESSAGE(msgbuf);
290:
291: ELSE
292:
293: fnd_flex_dsc_api.create_segment(
294: appl_short_name => 'INV',
295: flexfield_name => 'MTL_SYSTEM_ITEMS',
296: context_name => 'Global Data Elements',
297: name => 'Late Demands Penalty',

Line 332: IF fnd_flex_dsc_api.is_column_used(

328:
329:
330: IF item_attr2 IS NOT NULL THEN
331:
332: IF fnd_flex_dsc_api.is_column_used(
333: p_application_id => '401',
334: p_table_name => 'MTL_SYSTEM_ITEMS_B',
335: p_column_name => 'ATTRIBUTE'||to_char(item_attr2),
336: x_message => msgbuf) = TRUE THEN

Line 344: ELSIF fnd_flex_dsc_api.segment_exists(

340: FND_MESSAGE.set_token('TABLE','MTL_SYSTEM_ITEMS');
341: msgbuf := FND_MESSAGE.get;
342: LOG_MESSAGE(msgbuf);
343:
344: ELSIF fnd_flex_dsc_api.segment_exists(
345: p_appl_short_name=>'INV',
346: p_flexfield_name=>'MTL_SYSTEM_ITEMS',
347: p_context_code=>'Global Data Elements',
348: p_segment_name=>'Material Over-Capacity Penalty') = TRUE THEN

Line 358: fnd_flex_dsc_api.create_segment(

354: LOG_MESSAGE(msgbuf);
355:
356: ELSE
357:
358: fnd_flex_dsc_api.create_segment(
359: appl_short_name => 'INV',
360: flexfield_name => 'MTL_SYSTEM_ITEMS',
361: context_name => 'Global Data Elements',
362: name => 'Material Over-Capacity Penalty',

Line 397: fnd_flex_dsc_api.enable_context('INV',

393:
394:
395: IF org_attr1 IS NOT NULL THEN
396:
397: fnd_flex_dsc_api.enable_context('INV',
398: 'MTL_PARAMETERS',
399: 'Global Data Elements',
400: TRUE);
401:

Line 402: IF fnd_flex_dsc_api.is_column_used(

398: 'MTL_PARAMETERS',
399: 'Global Data Elements',
400: TRUE);
401:
402: IF fnd_flex_dsc_api.is_column_used(
403: p_application_id => '401',
404: p_table_name => 'MTL_PARAMETERS',
405: p_column_name => 'ATTRIBUTE'||to_char(org_attr1),
406: x_message => msgbuf) = TRUE THEN

Line 414: ELSIF fnd_flex_dsc_api.segment_exists(

410: FND_MESSAGE.set_token('TABLE','MTL_PARAMETERS');
411: msgbuf := FND_MESSAGE.get;
412: LOG_MESSAGE(msgbuf);
413:
414: ELSIF fnd_flex_dsc_api.segment_exists(
415: p_appl_short_name=>'INV',
416: p_flexfield_name=>'MTL_PARAMETERS',
417: p_context_code=>'Global Data Elements',
418: p_segment_name=>'Late Demands Penalty') = TRUE THEN

Line 428: fnd_flex_dsc_api.create_segment(

424: LOG_MESSAGE(msgbuf);
425:
426: ELSE
427:
428: fnd_flex_dsc_api.create_segment(
429: appl_short_name => 'INV',
430: flexfield_name => 'MTL_PARAMETERS',
431: context_name => 'Global Data Elements',
432: name => 'Late Demands Penalty',

Line 467: IF fnd_flex_dsc_api.is_column_used(

463:
464:
465: IF org_attr2 IS NOT NULL THEN
466:
467: IF fnd_flex_dsc_api.is_column_used(
468: p_application_id => '401',
469: p_table_name => 'MTL_PARAMETERS',
470: p_column_name => 'ATTRIBUTE'||to_char(org_attr2),
471: x_message => msgbuf) = TRUE THEN

Line 479: ELSIF fnd_flex_dsc_api.segment_exists(

475: FND_MESSAGE.set_token('TABLE','MTL_PARAMETERS');
476: msgbuf := FND_MESSAGE.get;
477: LOG_MESSAGE(msgbuf);
478:
479: ELSIF fnd_flex_dsc_api.segment_exists(
480: p_appl_short_name=>'INV',
481: p_flexfield_name=>'MTL_PARAMETERS',
482: p_context_code=>'Global Data Elements',
483: p_segment_name=>'Material Over-Capacity Penalty') = TRUE THEN

Line 493: fnd_flex_dsc_api.create_segment(

489: LOG_MESSAGE(msgbuf);
490:
491: ELSE
492:
493: fnd_flex_dsc_api.create_segment(
494: appl_short_name => 'INV',
495: flexfield_name => 'MTL_PARAMETERS',
496: context_name => 'Global Data Elements',
497: name => 'Material Over-Capacity Penalty',

Line 532: IF fnd_flex_dsc_api.is_column_used(

528:
529:
530: IF org_attr3 IS NOT NULL THEN
531:
532: IF fnd_flex_dsc_api.is_column_used(
533: p_application_id => '401',
534: p_table_name => 'MTL_PARAMETERS',
535: p_column_name => 'ATTRIBUTE'||to_char(org_attr3),
536: x_message => msgbuf) = TRUE THEN

Line 544: ELSIF fnd_flex_dsc_api.segment_exists(

540: FND_MESSAGE.set_token('TABLE','MTL_PARAMETERS');
541: msgbuf := FND_MESSAGE.get;
542: LOG_MESSAGE(msgbuf);
543:
544: ELSIF fnd_flex_dsc_api.segment_exists(
545: p_appl_short_name=>'INV',
546: p_flexfield_name=>'MTL_PARAMETERS',
547: p_context_code=>'Global Data Elements',
548: p_segment_name=>'Resource Over-Capacity Penalty') = TRUE THEN

Line 559: fnd_flex_dsc_api.create_segment(

555:
556: ELSE
557:
558:
559: fnd_flex_dsc_api.create_segment(
560: appl_short_name => 'INV',
561: flexfield_name => 'MTL_PARAMETERS',
562: context_name => 'Global Data Elements',
563: name => 'Resource Over-Capacity Penalty',

Line 598: IF fnd_flex_dsc_api.is_column_used(

594:
595:
596: IF org_attr4 IS NOT NULL THEN
597:
598: IF fnd_flex_dsc_api.is_column_used(
599: p_application_id => '401',
600: p_table_name => 'MTL_PARAMETERS',
601: p_column_name => 'ATTRIBUTE'||to_char(org_attr4),
602: x_message => msgbuf) = TRUE THEN

Line 610: ELSIF fnd_flex_dsc_api.segment_exists(

606: FND_MESSAGE.set_token('TABLE','MTL_PARAMETERS');
607: msgbuf := FND_MESSAGE.get;
608: LOG_MESSAGE(msgbuf);
609:
610: ELSIF fnd_flex_dsc_api.segment_exists(
611: p_appl_short_name=>'INV',
612: p_flexfield_name=>'MTL_PARAMETERS',
613: p_context_code=>'Global Data Elements',
614: p_segment_name=>'Transport Over-Cap Penalty') = TRUE THEN

Line 625: fnd_flex_dsc_api.create_segment(

621:
622: ELSE
623:
624:
625: fnd_flex_dsc_api.create_segment(
626: appl_short_name => 'INV',
627: flexfield_name => 'MTL_PARAMETERS',
628: context_name => 'Global Data Elements',
629: name => 'Transport Over-Cap Penalty',

Line 664: fnd_flex_dsc_api.enable_context('BOM',

660:
661:
662: IF dept_attr1 IS NOT NULL THEN
663:
664: fnd_flex_dsc_api.enable_context('BOM',
665: 'BOM_DEPARTMENT_RESOURCES',
666: 'Global Data Elements',
667: TRUE);
668:

Line 670: IF fnd_flex_dsc_api.is_column_used(

666: 'Global Data Elements',
667: TRUE);
668:
669:
670: IF fnd_flex_dsc_api.is_column_used(
671: p_application_id => '702',
672: p_table_name => 'BOM_DEPARTMENT_RESOURCES',
673: p_column_name => 'ATTRIBUTE'||to_char(dept_attr1),
674: x_message => msgbuf) = TRUE THEN

Line 682: ELSIF fnd_flex_dsc_api.segment_exists(

678: FND_MESSAGE.set_token('TABLE','BOM_DEPARTMENT_RESOURCES');
679: msgbuf := FND_MESSAGE.get;
680: LOG_MESSAGE(msgbuf);
681:
682: ELSIF fnd_flex_dsc_api.segment_exists(
683: p_appl_short_name=>'BOM',
684: p_flexfield_name=>'BOM_DEPARTMENT_RESOURCES',
685: p_context_code=>'Global Data Elements',
686: p_segment_name=>'Aggregate Resource') = TRUE THEN

Line 696: fnd_flex_dsc_api.create_segment(

692: LOG_MESSAGE(msgbuf);
693:
694: ELSE
695:
696: fnd_flex_dsc_api.create_segment(
697: appl_short_name => 'BOM',
698: flexfield_name => 'BOM_DEPARTMENT_RESOURCES',
699: context_name => 'Global Data Elements',
700: name => 'Aggregate Resource',

Line 733: /* IF fnd_flex_dsc_api.segment_exists(

729:
730: END IF; -- dept_attr1 is not null
731:
732:
733: /* IF fnd_flex_dsc_api.segment_exists(
734: p_appl_short_name => 'BOM',
735: p_flexfield_name => 'BOM_DEPARTMENT_RESOURCES',
736: p_context_code => 'Global Data Elements',
737: p_segment_name => NULL,

Line 743: IF fnd_flex_dsc_api.is_column_used(

739: */
740:
741: IF dept_attr2 IS NOT NULL THEN
742:
743: IF fnd_flex_dsc_api.is_column_used(
744: p_application_id => '702',
745: p_table_name => 'BOM_DEPARTMENT_RESOURCES',
746: p_column_name => 'ATTRIBUTE'||to_char(dept_attr2),
747: x_message => msgbuf) = TRUE THEN

Line 755: ELSIF fnd_flex_dsc_api.segment_exists(

751: FND_MESSAGE.set_token('TABLE','BOM_DEPARTMENT_RESOURCES');
752: msgbuf := FND_MESSAGE.get;
753: LOG_MESSAGE(msgbuf);
754:
755: ELSIF fnd_flex_dsc_api.segment_exists(
756: p_appl_short_name=>'BOM',
757: p_flexfield_name=>'BOM_DEPARTMENT_RESOURCES',
758: p_context_code=>'Global Data Elements',
759: p_segment_name=>'Resource Over-Capacity Penalty') = TRUE THEN

Line 769: fnd_flex_dsc_api.create_segment(

765: LOG_MESSAGE(msgbuf);
766:
767: ELSE
768:
769: fnd_flex_dsc_api.create_segment(
770: appl_short_name => 'BOM',
771: flexfield_name => 'BOM_DEPARTMENT_RESOURCES',
772: context_name => 'Global Data Elements',
773: name => 'Resource Over-Capacity Penalty',

Line 808: fnd_flex_dsc_api.enable_context('PO',

804:
805:
806: IF supp_attr1 IS NOT NULL THEN
807:
808: fnd_flex_dsc_api.enable_context('PO',
809: 'PO_ASL_ATTRIBUTES',
810: 'Global Data Elements',
811: TRUE);
812:

Line 813: IF fnd_flex_dsc_api.is_column_used(

809: 'PO_ASL_ATTRIBUTES',
810: 'Global Data Elements',
811: TRUE);
812:
813: IF fnd_flex_dsc_api.is_column_used(
814: p_application_id => '201',
815: p_table_name => 'PO_ASL_ATTRIBUTES',
816: p_column_name => 'ATTRIBUTE'||to_char(supp_attr1),
817: x_message => msgbuf) = TRUE THEN

Line 825: ELSIF fnd_flex_dsc_api.segment_exists(

821: FND_MESSAGE.set_token('TABLE','PO_ASL_ATTRIBUTES');
822: msgbuf := FND_MESSAGE.get;
823: LOG_MESSAGE(msgbuf);
824:
825: ELSIF fnd_flex_dsc_api.segment_exists(
826: p_appl_short_name=>'PO',
827: p_flexfield_name=>'PO_ASL_ATTRIBUTES',
828: p_context_code=>'Global Data Elements',
829: p_segment_name=>'Material Over-Capacity Penalty') = TRUE THEN

Line 839: fnd_flex_dsc_api.create_segment(

835: LOG_MESSAGE(msgbuf);
836:
837: ELSE
838:
839: fnd_flex_dsc_api.create_segment(
840: appl_short_name => 'PO',
841: flexfield_name => 'PO_ASL_ATTRIBUTES',
842: context_name => 'Global Data Elements',
843: name => 'Material Over-Capacity Penalty',

Line 878: fnd_flex_dsc_api.enable_context('BOM',

874:
875:
876: IF subst_attr1 IS NOT NULL THEN
877:
878: fnd_flex_dsc_api.enable_context('BOM',
879: 'BOM_SUBSTITUTE_COMPONENTS',
880: 'Global Data Elements',
881: TRUE);
882:

Line 884: IF fnd_flex_dsc_api.is_column_used(

880: 'Global Data Elements',
881: TRUE);
882:
883:
884: IF fnd_flex_dsc_api.is_column_used(
885: p_application_id => '702',
886: p_table_name => 'BOM_SUBSTITUTE_COMPONENTS',
887: p_column_name => 'ATTRIBUTE'||to_char(subst_attr1),
888: x_message => msgbuf) = TRUE THEN

Line 896: ELSIF fnd_flex_dsc_api.segment_exists(

892: FND_MESSAGE.set_token('TABLE','BOM_SUBSTITUTE_COMPONENTS');
893: msgbuf := FND_MESSAGE.get;
894: LOG_MESSAGE(msgbuf);
895:
896: ELSIF fnd_flex_dsc_api.segment_exists(
897: p_appl_short_name=>'BOM',
898: p_flexfield_name=>'BOM_SUBSTITUTE_COMPONENTS',
899: p_context_code=>'Global Data Elements',
900: p_segment_name=>'Substitute Priority') = TRUE THEN

Line 910: fnd_flex_dsc_api.create_segment(

906: LOG_MESSAGE(msgbuf);
907:
908: ELSE
909:
910: fnd_flex_dsc_api.create_segment(
911: appl_short_name => 'BOM',
912: flexfield_name => 'BOM_SUBSTITUTE_COMPONENTS',
913: context_name => 'Global Data Elements',
914: name => 'Substitute Priority',

Line 949: fnd_flex_dsc_api.enable_context('INV',

945:
946:
947: IF trans_attr1 IS NOT NULL THEN
948:
949: fnd_flex_dsc_api.enable_context('INV',
950: 'MTL_INTERORG_SHIP_METHODS',
951: 'Global Data Elements',
952: TRUE);
953:

Line 955: IF fnd_flex_dsc_api.is_column_used(

951: 'Global Data Elements',
952: TRUE);
953:
954:
955: IF fnd_flex_dsc_api.is_column_used(
956: p_application_id => '401',
957: p_table_name => 'MTL_INTERORG_SHIP_METHODS',
958: p_column_name => 'ATTRIBUTE'||to_char(trans_attr1),
959: x_message => msgbuf) = TRUE THEN

Line 967: ELSIF fnd_flex_dsc_api.segment_exists(

963: FND_MESSAGE.set_token('TABLE','MTL_INTERORG_SHIP_METHODS');
964: msgbuf := FND_MESSAGE.get;
965: LOG_MESSAGE(msgbuf);
966:
967: ELSIF fnd_flex_dsc_api.segment_exists(
968: p_appl_short_name=>'INV',
969: p_flexfield_name=>'MTL_INTERORG_SHIP_METHODS',
970: p_context_code=>'Global Data Elements',
971: p_segment_name=>'Transport Over-Cap Penalty') = TRUE THEN

Line 981: fnd_flex_dsc_api.create_segment(

977: LOG_MESSAGE(msgbuf);
978:
979: ELSE
980:
981: fnd_flex_dsc_api.create_segment(
982: appl_short_name => 'INV',
983: flexfield_name => 'MTL_INTERORG_SHIP_METHODS',
984: context_name => 'Global Data Elements',
985: name => 'Transport Over-Cap Penalty',

Line 1020: fnd_flex_dsc_api.enable_context('BOM',

1016:
1017:
1018: IF bom_attr1 IS NOT NULL THEN
1019:
1020: fnd_flex_dsc_api.enable_context('BOM',
1021: 'BOM_BILL_OF_MATERIALS',
1022: 'Global Data Elements',
1023: TRUE);
1024:

Line 1026: IF fnd_flex_dsc_api.is_column_used(

1022: 'Global Data Elements',
1023: TRUE);
1024:
1025:
1026: IF fnd_flex_dsc_api.is_column_used(
1027: p_application_id => '702',
1028: p_table_name => 'BOM_BILL_OF_MATERIALS',
1029: p_column_name => 'ATTRIBUTE'||to_char(bom_attr1),
1030: x_message => msgbuf) = TRUE THEN

Line 1038: ELSIF fnd_flex_dsc_api.segment_exists(

1034: FND_MESSAGE.set_token('TABLE','BOM_BILL_OF_MATERIALS');
1035: msgbuf := FND_MESSAGE.get;
1036: LOG_MESSAGE(msgbuf);
1037:
1038: ELSIF fnd_flex_dsc_api.segment_exists(
1039: p_appl_short_name=>'BOM',
1040: p_flexfield_name=>'BOM_BILL_OF_MATERIALS',
1041: p_context_code=>'Global Data Elements',
1042: p_segment_name=>'Cost of Using a BOM/Routing') = TRUE THEN

Line 1052: fnd_flex_dsc_api.create_segment(

1048: LOG_MESSAGE(msgbuf);
1049:
1050: ELSE
1051:
1052: fnd_flex_dsc_api.create_segment(
1053: appl_short_name => 'BOM',
1054: flexfield_name => 'BOM_BILL_OF_MATERIALS',
1055: context_name => 'Global Data Elements',
1056: name => 'Cost of Using a BOM/Routing',

Line 1091: fnd_flex_dsc_api.enable_context('MRP',

1087:
1088:
1089: IF forecast_attr1 IS NOT NULL THEN
1090:
1091: fnd_flex_dsc_api.enable_context('MRP',
1092: 'MRP_FORECAST_DATES',
1093: 'Global Data Elements',
1094: TRUE);
1095:

Line 1097: IF fnd_flex_dsc_api.is_column_used(

1093: 'Global Data Elements',
1094: TRUE);
1095:
1096:
1097: IF fnd_flex_dsc_api.is_column_used(
1098: p_application_id => '704',
1099: p_table_name => 'MRP_FORECAST_DATES',
1100: p_column_name => 'ATTRIBUTE'||to_char(forecast_attr1),
1101: x_message => msgbuf) = TRUE THEN

Line 1109: ELSIF fnd_flex_dsc_api.segment_exists(

1105: FND_MESSAGE.set_token('TABLE','MRP_FORECAST_DATES');
1106: msgbuf := FND_MESSAGE.get;
1107: LOG_MESSAGE(msgbuf);
1108:
1109: ELSIF fnd_flex_dsc_api.segment_exists(
1110: p_appl_short_name=>'MRP',
1111: p_flexfield_name=>'MRP_FORECAST_DATES',
1112: p_context_code=>'Global Data Elements',
1113: p_segment_name=>'Late Forecasts Penalty') = TRUE THEN

Line 1123: fnd_flex_dsc_api.create_segment(

1119: LOG_MESSAGE(msgbuf);
1120:
1121: ELSE
1122:
1123: fnd_flex_dsc_api.create_segment(
1124: appl_short_name => 'MRP',
1125: flexfield_name => 'MRP_FORECAST_DATES',
1126: context_name => 'Global Data Elements',
1127: name => 'Late Forecasts Penalty',

Line 1162: fnd_flex_dsc_api.enable_context('WIP',

1158:
1159:
1160: IF line_attr1 IS NOT NULL THEN
1161:
1162: fnd_flex_dsc_api.enable_context('WIP',
1163: 'WIP_LINES',
1164: 'Global Data Elements',
1165: TRUE);
1166:

Line 1167: IF fnd_flex_dsc_api.is_column_used(

1163: 'WIP_LINES',
1164: 'Global Data Elements',
1165: TRUE);
1166:
1167: IF fnd_flex_dsc_api.is_column_used(
1168: p_application_id => '706',
1169: p_table_name => 'WIP_LINES',
1170: p_column_name => 'ATTRIBUTE'||to_char(line_attr1),
1171: x_message => msgbuf) = TRUE THEN

Line 1179: ELSIF fnd_flex_dsc_api.segment_exists(

1175: FND_MESSAGE.set_token('TABLE','WIP_LINES');
1176: msgbuf := FND_MESSAGE.get;
1177: LOG_MESSAGE(msgbuf);
1178:
1179: ELSIF fnd_flex_dsc_api.segment_exists(
1180: p_appl_short_name=>'WIP',
1181: p_flexfield_name=>'WIP_LINES',
1182: p_context_code=>'Global Data Elements',
1183: p_segment_name=>'Resource Group') = TRUE THEN

Line 1193: fnd_flex_dsc_api.create_segment(

1189: LOG_MESSAGE(msgbuf);
1190:
1191: ELSE
1192:
1193: fnd_flex_dsc_api.create_segment(
1194: appl_short_name => 'WIP',
1195: flexfield_name => 'WIP_LINES',
1196: context_name => 'Global Data Elements',
1197: name => 'Resource Group',

Line 1230: fnd_flex_dsc_api.enable_context('MRP',

1226:
1227: END IF; --line_attr1 is not null
1228:
1229: if schedule_attr1 is not null then
1230: fnd_flex_dsc_api.enable_context('MRP',
1231: 'MRP_SCHEDULE_DATES',
1232: 'Global Data Elements',
1233: TRUE);
1234: IF fnd_flex_dsc_api.is_column_used(

Line 1234: IF fnd_flex_dsc_api.is_column_used(

1230: fnd_flex_dsc_api.enable_context('MRP',
1231: 'MRP_SCHEDULE_DATES',
1232: 'Global Data Elements',
1233: TRUE);
1234: IF fnd_flex_dsc_api.is_column_used(
1235: p_application_id => '704',
1236: p_table_name => 'MRP_SCHEDULE_DATES',
1237: p_column_name => 'ATTRIBUTE'||to_char(schedule_attr1),
1238: x_message => msgbuf) = TRUE THEN

Line 1245: ELSIF fnd_flex_dsc_api.segment_exists(

1241: FND_MESSAGE.set_token('ATTRIBUTE','ATTRIBUTE'||to_char(schedule_attr1));
1242: FND_MESSAGE.set_token('TABLE','MRP_SCHEDULE_DATES');
1243: msgbuf := FND_MESSAGE.get;
1244: LOG_MESSAGE(msgbuf);
1245: ELSIF fnd_flex_dsc_api.segment_exists(
1246: p_appl_short_name=>'MRP',
1247: p_flexfield_name=>'MRP_SCHEDULE_DATES',
1248: p_context_code=>'Global Data Elements',
1249: p_segment_name=>'Demand Priority') = TRUE THEN

Line 1258: fnd_flex_dsc_api.create_segment(

1254: msgbuf := FND_MESSAGE.get;
1255: LOG_MESSAGE(msgbuf);
1256:
1257: ELSE
1258: fnd_flex_dsc_api.create_segment(
1259: appl_short_name => 'MRP',
1260: flexfield_name => 'MRP_SCHEDULE_DATES',
1261: context_name => 'Global Data Elements',
1262: name => 'Demand Priority',

Line 1391: if (fnd_flex_dsc_api.message is null) then

1387: substr(fnd_message.get,1,240);
1388: retcode := 2;
1389: WHEN OTHERS THEN
1390: rollback;
1391: if (fnd_flex_dsc_api.message is null) then
1392: errbuf := 'Sql Error:' || to_char(sqlcode);
1393: else
1394: errbuf := fnd_flex_dsc_api.message;
1395: end if;

Line 1394: errbuf := fnd_flex_dsc_api.message;

1390: rollback;
1391: if (fnd_flex_dsc_api.message is null) then
1392: errbuf := 'Sql Error:' || to_char(sqlcode);
1393: else
1394: errbuf := fnd_flex_dsc_api.message;
1395: end if;
1396: retcode := 2; -- failure
1397: END Configure;
1398:

Line 1412: fnd_flex_dsc_api.debug_on;

1408: msgbuf VARCHAR2(2000);
1409:
1410: BEGIN
1411:
1412: fnd_flex_dsc_api.debug_on;
1413: fnd_flex_dsc_api.set_session_mode('seed_data');
1414:
1415: fnd_flex_dsc_api.enable_context('BOM',
1416: 'OPERATION_RESOURCES',

Line 1413: fnd_flex_dsc_api.set_session_mode('seed_data');

1409:
1410: BEGIN
1411:
1412: fnd_flex_dsc_api.debug_on;
1413: fnd_flex_dsc_api.set_session_mode('seed_data');
1414:
1415: fnd_flex_dsc_api.enable_context('BOM',
1416: 'OPERATION_RESOURCES',
1417: 'Global Data Elements',

Line 1415: fnd_flex_dsc_api.enable_context('BOM',

1411:
1412: fnd_flex_dsc_api.debug_on;
1413: fnd_flex_dsc_api.set_session_mode('seed_data');
1414:
1415: fnd_flex_dsc_api.enable_context('BOM',
1416: 'OPERATION_RESOURCES',
1417: 'Global Data Elements',
1418: TRUE);
1419:

Line 1421: fnd_flex_dsc_api.is_column_used(

1417: 'Global Data Elements',
1418: TRUE);
1419:
1420: IF
1421: fnd_flex_dsc_api.is_column_used(
1422: p_application_id => '702',
1423: p_table_name => 'OPERATION_RESOURCES',
1424: p_column_name => 'ATTRIBUTE'||to_char(oper_attr1),
1425: x_message => msgbuf) = TRUE THEN

Line 1433: fnd_flex_dsc_api.segment_exists(

1429: FND_MESSAGE.set_token('TABLE','OPERATION_RESOURCES');
1430: msgbuf := FND_MESSAGE.get;
1431: LOG_MESSAGE(msgbuf);
1432: ELSIF
1433: fnd_flex_dsc_api.segment_exists(
1434: p_appl_short_name=>'BOM',
1435: p_flexfield_name=>'OPERATION_RESOURCES',
1436: p_context_code=>'Global Data Elements',
1437: p_segment_name=>'Activity Group Id') = TRUE THEN

Line 1444: fnd_flex_dsc_api.create_segment(

1440: FND_MESSAGE.set_token('TABLE','OPERATION_RESOURCES');
1441: msgbuf := FND_MESSAGE.get;
1442: LOG_MESSAGE(msgbuf);
1443: ELSE
1444: fnd_flex_dsc_api.create_segment(
1445: appl_short_name => 'BOM',
1446: flexfield_name => 'OPERATION_RESOURCES',
1447: context_name => 'Global Data Elements',
1448: name => 'Activity Group Id',

Line 1469: fnd_flex_dsc_api.enable_context('BOM',

1465: srw_parameter => NULL);
1466: END IF;
1467:
1468:
1469: fnd_flex_dsc_api.enable_context('BOM',
1470: 'SUB_OPERATION_RESOURCES',
1471: 'Global Data Elements',
1472: TRUE);
1473: -- fix for Bug 2748600

Line 1475: fnd_flex_dsc_api.segment_exists(

1471: 'Global Data Elements',
1472: TRUE);
1473: -- fix for Bug 2748600
1474: IF
1475: fnd_flex_dsc_api.segment_exists(
1476: p_appl_short_name=>'BOM',
1477: p_flexfield_name=>'SUB_OPERATION_RESOURCES',
1478: p_context_code=>'Global Data Elements',
1479: p_segment_name=>'Activity Grp Id - Alt Resource') = TRUE THEN

Line 1480: fnd_flex_dsc_api.delete_segment(

1476: p_appl_short_name=>'BOM',
1477: p_flexfield_name=>'SUB_OPERATION_RESOURCES',
1478: p_context_code=>'Global Data Elements',
1479: p_segment_name=>'Activity Grp Id - Alt Resource') = TRUE THEN
1480: fnd_flex_dsc_api.delete_segment(
1481: appl_short_name => 'BOM',
1482: flexfield_name => 'SUB_OPERATION_RESOURCES',
1483: context => 'Global Data Elements',
1484: segment => 'Activity Grp Id - Alt Resource');

Line 1519: if (fnd_flex_dsc_api.message is null) then

1515: retcode := 2;
1516:
1517: WHEN OTHERS THEN
1518: rollback;
1519: if (fnd_flex_dsc_api.message is null) then
1520: errbuf := 'Sql Error:' || to_char(sqlcode);
1521: else
1522: errbuf := fnd_flex_dsc_api.message;
1523: end if;

Line 1522: errbuf := fnd_flex_dsc_api.message;

1518: rollback;
1519: if (fnd_flex_dsc_api.message is null) then
1520: errbuf := 'Sql Error:' || to_char(sqlcode);
1521: else
1522: errbuf := fnd_flex_dsc_api.message;
1523: end if;
1524: retcode := 2; -- failure
1525:
1526: END Configure_strn_flex;

Line 1546: fnd_flex_dsc_api.debug_on;

1542: msgbuf VARCHAR2(2000);
1543:
1544: Begin
1545:
1546: fnd_flex_dsc_api.debug_on;
1547: fnd_flex_dsc_api.set_session_mode('seed_data');
1548:
1549: fnd_flex_dsc_api.enable_context('BOM',
1550: 'BOM_DEPARTMENT_RESOURCES',

Line 1547: fnd_flex_dsc_api.set_session_mode('seed_data');

1543:
1544: Begin
1545:
1546: fnd_flex_dsc_api.debug_on;
1547: fnd_flex_dsc_api.set_session_mode('seed_data');
1548:
1549: fnd_flex_dsc_api.enable_context('BOM',
1550: 'BOM_DEPARTMENT_RESOURCES',
1551: 'Global Data Elements',

Line 1549: fnd_flex_dsc_api.enable_context('BOM',

1545:
1546: fnd_flex_dsc_api.debug_on;
1547: fnd_flex_dsc_api.set_session_mode('seed_data');
1548:
1549: fnd_flex_dsc_api.enable_context('BOM',
1550: 'BOM_DEPARTMENT_RESOURCES',
1551: 'Global Data Elements',
1552: TRUE);
1553:

Line 1555: fnd_flex_dsc_api.is_column_used(

1551: 'Global Data Elements',
1552: TRUE);
1553:
1554: IF
1555: fnd_flex_dsc_api.is_column_used(
1556: p_application_id => '702',
1557: p_table_name => 'BOM_DEPARTMENT_RESOURCES',
1558: p_column_name => 'ATTRIBUTE'||to_char(bom_attr1),
1559: x_message => msgbuf) = TRUE THEN

Line 1567: fnd_flex_dsc_api.segment_exists(

1563: FND_MESSAGE.set_token('TABLE','BOM_DEPARTMENT_RESOURCES');
1564: msgbuf := FND_MESSAGE.get;
1565: LOG_MESSAGE(msgbuf);
1566: ELSIF
1567: fnd_flex_dsc_api.segment_exists(
1568: p_appl_short_name=>'BOM',
1569: p_flexfield_name=>'BOM_DEPARTMENT_RESOURCES',
1570: p_context_code=>'Global Data Elements',
1571: p_segment_name=>'Batchable Flag') = TRUE THEN

Line 1578: fnd_flex_dsc_api.create_segment(

1574: FND_MESSAGE.set_token('TABLE','BOM_DEPARTMENT_RESOURCES');
1575: msgbuf := FND_MESSAGE.get;
1576: LOG_MESSAGE(msgbuf);
1577: ELSE
1578: fnd_flex_dsc_api.create_segment(
1579: appl_short_name => 'BOM',
1580: flexfield_name => 'BOM_DEPARTMENT_RESOURCES',
1581: context_name => 'Global Data Elements',
1582: name => 'Batchable Flag',

Line 1616: fnd_flex_dsc_api.is_column_used(

1612: COMMIT;
1613:
1614:
1615: IF
1616: fnd_flex_dsc_api.is_column_used(
1617: p_application_id => '702',
1618: p_table_name => 'BOM_DEPARTMENT_RESOURCES',
1619: p_column_name => 'ATTRIBUTE'||to_char(bom_attr2),
1620: x_message => msgbuf) = TRUE THEN

Line 1628: fnd_flex_dsc_api.segment_exists(

1624: FND_MESSAGE.set_token('TABLE','BOM_DEPARTMENT_RESOURCES');
1625: msgbuf := FND_MESSAGE.get;
1626: LOG_MESSAGE(msgbuf);
1627: ELSIF
1628: fnd_flex_dsc_api.segment_exists(
1629: p_appl_short_name=>'BOM',
1630: p_flexfield_name=>'BOM_DEPARTMENT_RESOURCES',
1631: p_context_code=>'Global Data Elements',
1632: p_segment_name=>'Batching Window') = TRUE THEN

Line 1639: fnd_flex_dsc_api.create_segment(

1635: FND_MESSAGE.set_token('TABLE','BOM_DEPARTMENT_RESOURCES');
1636: msgbuf := FND_MESSAGE.get;
1637: LOG_MESSAGE(msgbuf);
1638: ELSE
1639: fnd_flex_dsc_api.create_segment(
1640: appl_short_name => 'BOM',
1641: flexfield_name => 'BOM_DEPARTMENT_RESOURCES',
1642: context_name => 'Global Data Elements',
1643: name => 'Batching Window',

Line 1675: fnd_flex_dsc_api.is_column_used(

1671: END IF;
1672: COMMIT;
1673:
1674: IF
1675: fnd_flex_dsc_api.is_column_used(
1676: p_application_id => '702',
1677: p_table_name => 'BOM_DEPARTMENT_RESOURCES',
1678: p_column_name => 'ATTRIBUTE'||to_char(bom_attr3),
1679: x_message => msgbuf) = TRUE THEN

Line 1687: fnd_flex_dsc_api.segment_exists(

1683: FND_MESSAGE.set_token('TABLE','BOM_DEPARTMENT_RESOURCES');
1684: msgbuf := FND_MESSAGE.get;
1685: LOG_MESSAGE(msgbuf);
1686: ELSIF
1687: fnd_flex_dsc_api.segment_exists(
1688: p_appl_short_name=>'BOM',
1689: p_flexfield_name=>'BOM_DEPARTMENT_RESOURCES',
1690: p_context_code=>'Global Data Elements',
1691: p_segment_name=>'Minimum Batch Capacity') = TRUE THEN

Line 1698: fnd_flex_dsc_api.create_segment(

1694: FND_MESSAGE.set_token('TABLE','BOM_DEPARTMENT_RESOURCES');
1695: msgbuf := FND_MESSAGE.get;
1696: LOG_MESSAGE(msgbuf);
1697: ELSE
1698: fnd_flex_dsc_api.create_segment(
1699: appl_short_name => 'BOM',
1700: flexfield_name => 'BOM_DEPARTMENT_RESOURCES',
1701: context_name => 'Global Data Elements',
1702: name => 'Minimum Batch Capacity',

Line 1734: fnd_flex_dsc_api.is_column_used(

1730: END IF;
1731: COMMIT;
1732:
1733: IF
1734: fnd_flex_dsc_api.is_column_used(
1735: p_application_id => '702',
1736: p_table_name => 'BOM_DEPARTMENT_RESOURCES',
1737: p_column_name => 'ATTRIBUTE'||to_char(bom_attr4),
1738: x_message => msgbuf) = TRUE THEN

Line 1746: fnd_flex_dsc_api.segment_exists(

1742: FND_MESSAGE.set_token('TABLE','BOM_DEPARTMENT_RESOURCES');
1743: msgbuf := FND_MESSAGE.get;
1744: LOG_MESSAGE(msgbuf);
1745: ELSIF
1746: fnd_flex_dsc_api.segment_exists(
1747: p_appl_short_name=>'BOM',
1748: p_flexfield_name=>'BOM_DEPARTMENT_RESOURCES',
1749: p_context_code=>'Global Data Elements',
1750: p_segment_name=>'Maximum Batch Capacity') = TRUE THEN

Line 1757: fnd_flex_dsc_api.create_segment(

1753: FND_MESSAGE.set_token('TABLE','BOM_DEPARTMENT_RESOURCES');
1754: msgbuf := FND_MESSAGE.get;
1755: LOG_MESSAGE(msgbuf);
1756: ELSE
1757: fnd_flex_dsc_api.create_segment(
1758: appl_short_name => 'BOM',
1759: flexfield_name => 'BOM_DEPARTMENT_RESOURCES',
1760: context_name => 'Global Data Elements',
1761: name => 'Maximum Batch Capacity',

Line 1793: fnd_flex_dsc_api.is_column_used(

1789: END IF;
1790: COMMIT;
1791:
1792: IF
1793: fnd_flex_dsc_api.is_column_used(
1794: p_application_id => '702',
1795: p_table_name => 'BOM_DEPARTMENT_RESOURCES',
1796: p_column_name => 'ATTRIBUTE'||to_char(bom_attr5),
1797: x_message => msgbuf) = TRUE THEN

Line 1805: fnd_flex_dsc_api.segment_exists(

1801: FND_MESSAGE.set_token('TABLE','BOM_DEPARTMENT_RESOURCES');
1802: msgbuf := FND_MESSAGE.get;
1803: LOG_MESSAGE(msgbuf);
1804: ELSIF
1805: fnd_flex_dsc_api.segment_exists(
1806: p_appl_short_name=>'BOM',
1807: p_flexfield_name=>'BOM_DEPARTMENT_RESOURCES',
1808: p_context_code=>'Global Data Elements',
1809: p_segment_name=>'Batchable Unit of Measure') = TRUE THEN

Line 1816: fnd_flex_dsc_api.create_segment(

1812: FND_MESSAGE.set_token('TABLE','BOM_DEPARTMENT_RESOURCES');
1813: msgbuf := FND_MESSAGE.get;
1814: LOG_MESSAGE(msgbuf);
1815: ELSE
1816: fnd_flex_dsc_api.create_segment(
1817: appl_short_name => 'BOM',
1818: flexfield_name => 'BOM_DEPARTMENT_RESOURCES',
1819: context_name => 'Global Data Elements',
1820: name => 'Batchable Unit of Measure',

Line 1873: if (fnd_flex_dsc_api.message is null) then

1869: retcode := 2;
1870:
1871: WHEN OTHERS THEN
1872: rollback;
1873: if (fnd_flex_dsc_api.message is null) then
1874: errbuf := 'Sql Error:' || to_char(sqlcode);
1875: else
1876: errbuf := fnd_flex_dsc_api.message;
1877: end if;

Line 1876: errbuf := fnd_flex_dsc_api.message;

1872: rollback;
1873: if (fnd_flex_dsc_api.message is null) then
1874: errbuf := 'Sql Error:' || to_char(sqlcode);
1875: else
1876: errbuf := fnd_flex_dsc_api.message;
1877: end if;
1878: retcode := 2; -- failure
1879:
1880: END Configure_reba_flex;

Line 1894: fnd_flex_dsc_api.debug_on;

1890: msgbuf VARCHAR2(2000);
1891:
1892: BEGIN
1893:
1894: fnd_flex_dsc_api.debug_on;
1895: fnd_flex_dsc_api.set_session_mode('seed_data');
1896:
1897: fnd_flex_dsc_api.enable_context('MRP',
1898: 'MRP_FORECAST_DATES',

Line 1895: fnd_flex_dsc_api.set_session_mode('seed_data');

1891:
1892: BEGIN
1893:
1894: fnd_flex_dsc_api.debug_on;
1895: fnd_flex_dsc_api.set_session_mode('seed_data');
1896:
1897: fnd_flex_dsc_api.enable_context('MRP',
1898: 'MRP_FORECAST_DATES',
1899: 'Global Data Elements',

Line 1897: fnd_flex_dsc_api.enable_context('MRP',

1893:
1894: fnd_flex_dsc_api.debug_on;
1895: fnd_flex_dsc_api.set_session_mode('seed_data');
1896:
1897: fnd_flex_dsc_api.enable_context('MRP',
1898: 'MRP_FORECAST_DATES',
1899: 'Global Data Elements',
1900: TRUE);
1901:

Line 1902: IF fnd_flex_dsc_api.is_column_used(

1898: 'MRP_FORECAST_DATES',
1899: 'Global Data Elements',
1900: TRUE);
1901:
1902: IF fnd_flex_dsc_api.is_column_used(
1903: p_application_id => '704',
1904: p_table_name => 'MRP_FORECAST_DATES',
1905: p_column_name => 'ATTRIBUTE'||to_char(fcst_attr1),
1906: x_message => msgbuf) = TRUE THEN

Line 1914: ELSIF fnd_flex_dsc_api.segment_exists(

1910: FND_MESSAGE.set_token('TABLE','MRP_FORECAST_DATES');
1911: msgbuf := FND_MESSAGE.get;
1912: LOG_MESSAGE(msgbuf);
1913:
1914: ELSIF fnd_flex_dsc_api.segment_exists(
1915: p_appl_short_name=>'MRP',
1916: p_flexfield_name=>'MRP_FORECAST_DATES',
1917: p_context_code=>'Global Data Elements',
1918: p_segment_name=>'Forecast Priority') = TRUE THEN

Line 1927: fnd_flex_dsc_api.create_segment(

1923: msgbuf := FND_MESSAGE.get;
1924: LOG_MESSAGE(msgbuf);
1925:
1926: ELSE
1927: fnd_flex_dsc_api.create_segment(
1928: appl_short_name => 'MRP',
1929: flexfield_name => 'MRP_FORECAST_DATES',
1930: context_name => 'Global Data Elements',
1931: name => 'Forecast Priority',

Line 1982: if (fnd_flex_dsc_api.message is null) then

1978: substr(fnd_message.get,1,240);
1979: retcode := 2;
1980: WHEN OTHERS THEN
1981: rollback;
1982: if (fnd_flex_dsc_api.message is null) then
1983: errbuf := 'Sql Error:' || to_char(sqlcode);
1984: else
1985: errbuf := fnd_flex_dsc_api.message;
1986: end if;

Line 1985: errbuf := fnd_flex_dsc_api.message;

1981: rollback;
1982: if (fnd_flex_dsc_api.message is null) then
1983: errbuf := 'Sql Error:' || to_char(sqlcode);
1984: else
1985: errbuf := fnd_flex_dsc_api.message;
1986: end if;
1987: retcode := 2; -- failure
1988:
1989: END Configure_fcst_flex;

Line 2004: fnd_flex_dsc_api.debug_on;

2000: msgbuf VARCHAR2(2000);
2001:
2002: BEGIN
2003:
2004: fnd_flex_dsc_api.debug_on;
2005: fnd_flex_dsc_api.set_session_mode('seed_data');
2006:
2007: fnd_flex_dsc_api.enable_context('WSH',
2008: 'WSH_REGIONS',

Line 2005: fnd_flex_dsc_api.set_session_mode('seed_data');

2001:
2002: BEGIN
2003:
2004: fnd_flex_dsc_api.debug_on;
2005: fnd_flex_dsc_api.set_session_mode('seed_data');
2006:
2007: fnd_flex_dsc_api.enable_context('WSH',
2008: 'WSH_REGIONS',
2009: 'ZONES_DFF',

Line 2007: fnd_flex_dsc_api.enable_context('WSH',

2003:
2004: fnd_flex_dsc_api.debug_on;
2005: fnd_flex_dsc_api.set_session_mode('seed_data');
2006:
2007: fnd_flex_dsc_api.enable_context('WSH',
2008: 'WSH_REGIONS',
2009: 'ZONES_DFF',
2010: TRUE);
2011:

Line 2013: fnd_flex_dsc_api.is_column_used(

2009: 'ZONES_DFF',
2010: TRUE);
2011:
2012: IF
2013: fnd_flex_dsc_api.is_column_used(
2014: p_application_id => '665',
2015: p_table_name => 'WSH_REGIONS',
2016: p_column_name => 'ATTRIBUTE'||to_char(oper_attr1),
2017: x_message => msgbuf) = TRUE THEN

Line 2025: fnd_flex_dsc_api.segment_exists(

2021: FND_MESSAGE.set_token('TABLE','WSH_REGIONS');
2022: msgbuf := FND_MESSAGE.get;
2023: LOG_MESSAGE(msgbuf);
2024: ELSIF
2025: fnd_flex_dsc_api.segment_exists(
2026: p_appl_short_name=>'WSH',
2027: p_flexfield_name=>'WSH_REGIONS',
2028: p_context_code=>'ZONES_DFF',
2029: p_segment_name=>'Zone Usage') = TRUE THEN

Line 2036: fnd_flex_dsc_api.create_segment(

2032: FND_MESSAGE.set_token('TABLE','WSH_REGIONS');
2033: msgbuf := FND_MESSAGE.get;
2034: LOG_MESSAGE(msgbuf);
2035: ELSE
2036: fnd_flex_dsc_api.create_segment(
2037: appl_short_name => 'WSH',
2038: flexfield_name => 'WSH_REGIONS',
2039: context_name => 'ZONES_DFF',
2040: name => 'Zone Usage',

Line 2085: if (fnd_flex_dsc_api.message is null) then

2081: retcode := 2;
2082:
2083: WHEN OTHERS THEN
2084: rollback;
2085: if (fnd_flex_dsc_api.message is null) then
2086: errbuf := 'Sql Error:' || to_char(sqlcode);
2087: else
2088: errbuf := fnd_flex_dsc_api.message;
2089: end if;

Line 2088: errbuf := fnd_flex_dsc_api.message;

2084: rollback;
2085: if (fnd_flex_dsc_api.message is null) then
2086: errbuf := 'Sql Error:' || to_char(sqlcode);
2087: else
2088: errbuf := fnd_flex_dsc_api.message;
2089: end if;
2090: retcode := 2; -- failure
2091:
2092: END Configure_regions_flex;