APPS.MSC_CONFIG_FF dependencies on FND_MESSAGE

Line 49: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');

45: p_flexfield_name=>'MTL_SYSTEM_ITEMS',
46: p_context_code=>'Global Data Elements',
47: p_segment_name=>'Service Level') = TRUE THEN
48:
49: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');
50: FND_MESSAGE.set_token('SEGMENT','Service Level');
51: FND_MESSAGE.set_token('TABLE','MTL_SYSTEM_ITEMS');
52: msgbuf := FND_MESSAGE.get;
53: LOG_MESSAGE(msgbuf);

Line 50: FND_MESSAGE.set_token('SEGMENT','Service Level');

46: p_context_code=>'Global Data Elements',
47: p_segment_name=>'Service Level') = TRUE THEN
48:
49: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');
50: FND_MESSAGE.set_token('SEGMENT','Service Level');
51: FND_MESSAGE.set_token('TABLE','MTL_SYSTEM_ITEMS');
52: msgbuf := FND_MESSAGE.get;
53: LOG_MESSAGE(msgbuf);
54:

Line 51: FND_MESSAGE.set_token('TABLE','MTL_SYSTEM_ITEMS');

47: p_segment_name=>'Service Level') = TRUE THEN
48:
49: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');
50: FND_MESSAGE.set_token('SEGMENT','Service Level');
51: FND_MESSAGE.set_token('TABLE','MTL_SYSTEM_ITEMS');
52: msgbuf := FND_MESSAGE.get;
53: LOG_MESSAGE(msgbuf);
54:
55: ELSE

Line 52: msgbuf := FND_MESSAGE.get;

48:
49: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');
50: FND_MESSAGE.set_token('SEGMENT','Service Level');
51: FND_MESSAGE.set_token('TABLE','MTL_SYSTEM_ITEMS');
52: msgbuf := FND_MESSAGE.get;
53: LOG_MESSAGE(msgbuf);
54:
55: ELSE
56:

Line 98: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');

94: p_flexfield_name=>'MTL_PARAMETERS',
95: p_context_code=>'Global Data Elements',
96: p_segment_name=>'Service Level') = TRUE THEN
97:
98: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');
99: FND_MESSAGE.set_token('SEGMENT','Service Level');
100: FND_MESSAGE.set_token('TABLE','MTL_PARAMETERS');
101: msgbuf := FND_MESSAGE.get;
102: LOG_MESSAGE(msgbuf);

Line 99: FND_MESSAGE.set_token('SEGMENT','Service Level');

95: p_context_code=>'Global Data Elements',
96: p_segment_name=>'Service Level') = TRUE THEN
97:
98: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');
99: FND_MESSAGE.set_token('SEGMENT','Service Level');
100: FND_MESSAGE.set_token('TABLE','MTL_PARAMETERS');
101: msgbuf := FND_MESSAGE.get;
102: LOG_MESSAGE(msgbuf);
103:

Line 100: FND_MESSAGE.set_token('TABLE','MTL_PARAMETERS');

96: p_segment_name=>'Service Level') = TRUE THEN
97:
98: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');
99: FND_MESSAGE.set_token('SEGMENT','Service Level');
100: FND_MESSAGE.set_token('TABLE','MTL_PARAMETERS');
101: msgbuf := FND_MESSAGE.get;
102: LOG_MESSAGE(msgbuf);
103:
104: ELSE

Line 101: msgbuf := FND_MESSAGE.get;

97:
98: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');
99: FND_MESSAGE.set_token('SEGMENT','Service Level');
100: FND_MESSAGE.set_token('TABLE','MTL_PARAMETERS');
101: msgbuf := FND_MESSAGE.get;
102: LOG_MESSAGE(msgbuf);
103:
104: ELSE
105:

Line 147: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');

143: p_flexfield_name=>'RA_CUSTOMERS_HZ',
144: p_context_code=>'Global Data Elements',
145: p_segment_name=>'Service Level') = TRUE THEN
146:
147: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');
148: FND_MESSAGE.set_token('SEGMENT','Service Level');
149: FND_MESSAGE.set_token('TABLE','HZ_CUST_ACCOUNTS');
150: msgbuf := FND_MESSAGE.get;
151: LOG_MESSAGE(msgbuf);

Line 148: FND_MESSAGE.set_token('SEGMENT','Service Level');

144: p_context_code=>'Global Data Elements',
145: p_segment_name=>'Service Level') = TRUE THEN
146:
147: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');
148: FND_MESSAGE.set_token('SEGMENT','Service Level');
149: FND_MESSAGE.set_token('TABLE','HZ_CUST_ACCOUNTS');
150: msgbuf := FND_MESSAGE.get;
151: LOG_MESSAGE(msgbuf);
152:

Line 149: FND_MESSAGE.set_token('TABLE','HZ_CUST_ACCOUNTS');

145: p_segment_name=>'Service Level') = TRUE THEN
146:
147: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');
148: FND_MESSAGE.set_token('SEGMENT','Service Level');
149: FND_MESSAGE.set_token('TABLE','HZ_CUST_ACCOUNTS');
150: msgbuf := FND_MESSAGE.get;
151: LOG_MESSAGE(msgbuf);
152:
153: ELSE

Line 150: msgbuf := FND_MESSAGE.get;

146:
147: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');
148: FND_MESSAGE.set_token('SEGMENT','Service Level');
149: FND_MESSAGE.set_token('TABLE','HZ_CUST_ACCOUNTS');
150: msgbuf := FND_MESSAGE.get;
151: LOG_MESSAGE(msgbuf);
152:
153: ELSE
154:

Line 213: substr(fnd_message.get,1,240);

209: retcode := 0; -- success
210: EXCEPTION
211: WHEN conc_failure THEN
212: errbuf := 'Error ' ||
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

Line 273: FND_MESSAGE.set_name('MSC','MSC_ATTRIBUTE_EXISTS');

269: p_column_name => 'ATTRIBUTE'||to_char(item_attr1),
270: x_message => msgbuf) = TRUE THEN
271:
272:
273: FND_MESSAGE.set_name('MSC','MSC_ATTRIBUTE_EXISTS');
274: FND_MESSAGE.set_token('ATTRIBUTE','ATTRIBUTE'||to_char(item_attr1));
275: FND_MESSAGE.set_token('TABLE','MTL_SYSTEM_ITEMS');
276: msgbuf := FND_MESSAGE.get;
277: LOG_MESSAGE(msgbuf);

Line 274: FND_MESSAGE.set_token('ATTRIBUTE','ATTRIBUTE'||to_char(item_attr1));

270: x_message => msgbuf) = TRUE THEN
271:
272:
273: FND_MESSAGE.set_name('MSC','MSC_ATTRIBUTE_EXISTS');
274: FND_MESSAGE.set_token('ATTRIBUTE','ATTRIBUTE'||to_char(item_attr1));
275: FND_MESSAGE.set_token('TABLE','MTL_SYSTEM_ITEMS');
276: msgbuf := FND_MESSAGE.get;
277: LOG_MESSAGE(msgbuf);
278:

Line 275: FND_MESSAGE.set_token('TABLE','MTL_SYSTEM_ITEMS');

271:
272:
273: FND_MESSAGE.set_name('MSC','MSC_ATTRIBUTE_EXISTS');
274: FND_MESSAGE.set_token('ATTRIBUTE','ATTRIBUTE'||to_char(item_attr1));
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(

Line 276: msgbuf := FND_MESSAGE.get;

272:
273: FND_MESSAGE.set_name('MSC','MSC_ATTRIBUTE_EXISTS');
274: FND_MESSAGE.set_token('ATTRIBUTE','ATTRIBUTE'||to_char(item_attr1));
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',

Line 285: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');

281: p_flexfield_name=>'MTL_SYSTEM_ITEMS',
282: p_context_code=>'Global Data Elements',
283: p_segment_name=>'Late Demands Penalty') = TRUE THEN
284:
285: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');
286: FND_MESSAGE.set_token('SEGMENT','Late Demands Penalty');
287: FND_MESSAGE.set_token('TABLE','MTL_SYSTEM_ITEMS');
288: msgbuf := FND_MESSAGE.get;
289: LOG_MESSAGE(msgbuf);

Line 286: FND_MESSAGE.set_token('SEGMENT','Late Demands Penalty');

282: p_context_code=>'Global Data Elements',
283: p_segment_name=>'Late Demands Penalty') = TRUE THEN
284:
285: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');
286: FND_MESSAGE.set_token('SEGMENT','Late Demands Penalty');
287: FND_MESSAGE.set_token('TABLE','MTL_SYSTEM_ITEMS');
288: msgbuf := FND_MESSAGE.get;
289: LOG_MESSAGE(msgbuf);
290:

Line 287: FND_MESSAGE.set_token('TABLE','MTL_SYSTEM_ITEMS');

283: p_segment_name=>'Late Demands Penalty') = TRUE THEN
284:
285: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');
286: FND_MESSAGE.set_token('SEGMENT','Late Demands Penalty');
287: FND_MESSAGE.set_token('TABLE','MTL_SYSTEM_ITEMS');
288: msgbuf := FND_MESSAGE.get;
289: LOG_MESSAGE(msgbuf);
290:
291: ELSE

Line 288: msgbuf := FND_MESSAGE.get;

284:
285: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');
286: FND_MESSAGE.set_token('SEGMENT','Late Demands Penalty');
287: FND_MESSAGE.set_token('TABLE','MTL_SYSTEM_ITEMS');
288: msgbuf := FND_MESSAGE.get;
289: LOG_MESSAGE(msgbuf);
290:
291: ELSE
292:

Line 338: FND_MESSAGE.set_name('MSC','MSC_ATTRIBUTE_EXISTS');

334: p_table_name => 'MTL_SYSTEM_ITEMS_B',
335: p_column_name => 'ATTRIBUTE'||to_char(item_attr2),
336: x_message => msgbuf) = TRUE THEN
337:
338: FND_MESSAGE.set_name('MSC','MSC_ATTRIBUTE_EXISTS');
339: FND_MESSAGE.set_token('ATTRIBUTE','ATTRIBUTE'||to_char(item_attr2));
340: FND_MESSAGE.set_token('TABLE','MTL_SYSTEM_ITEMS');
341: msgbuf := FND_MESSAGE.get;
342: LOG_MESSAGE(msgbuf);

Line 339: FND_MESSAGE.set_token('ATTRIBUTE','ATTRIBUTE'||to_char(item_attr2));

335: p_column_name => 'ATTRIBUTE'||to_char(item_attr2),
336: x_message => msgbuf) = TRUE THEN
337:
338: FND_MESSAGE.set_name('MSC','MSC_ATTRIBUTE_EXISTS');
339: FND_MESSAGE.set_token('ATTRIBUTE','ATTRIBUTE'||to_char(item_attr2));
340: FND_MESSAGE.set_token('TABLE','MTL_SYSTEM_ITEMS');
341: msgbuf := FND_MESSAGE.get;
342: LOG_MESSAGE(msgbuf);
343:

Line 340: FND_MESSAGE.set_token('TABLE','MTL_SYSTEM_ITEMS');

336: x_message => msgbuf) = TRUE THEN
337:
338: FND_MESSAGE.set_name('MSC','MSC_ATTRIBUTE_EXISTS');
339: FND_MESSAGE.set_token('ATTRIBUTE','ATTRIBUTE'||to_char(item_attr2));
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(

Line 341: msgbuf := FND_MESSAGE.get;

337:
338: FND_MESSAGE.set_name('MSC','MSC_ATTRIBUTE_EXISTS');
339: FND_MESSAGE.set_token('ATTRIBUTE','ATTRIBUTE'||to_char(item_attr2));
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',

Line 350: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');

346: p_flexfield_name=>'MTL_SYSTEM_ITEMS',
347: p_context_code=>'Global Data Elements',
348: p_segment_name=>'Material Over-Capacity Penalty') = TRUE THEN
349:
350: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');
351: FND_MESSAGE.set_token('SEGMENT','Material Over-Capacity Penalty');
352: FND_MESSAGE.set_token('TABLE','MTL_SYSTEM_ITEMS');
353: msgbuf := FND_MESSAGE.get;
354: LOG_MESSAGE(msgbuf);

Line 351: FND_MESSAGE.set_token('SEGMENT','Material Over-Capacity Penalty');

347: p_context_code=>'Global Data Elements',
348: p_segment_name=>'Material Over-Capacity Penalty') = TRUE THEN
349:
350: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');
351: FND_MESSAGE.set_token('SEGMENT','Material Over-Capacity Penalty');
352: FND_MESSAGE.set_token('TABLE','MTL_SYSTEM_ITEMS');
353: msgbuf := FND_MESSAGE.get;
354: LOG_MESSAGE(msgbuf);
355:

Line 352: FND_MESSAGE.set_token('TABLE','MTL_SYSTEM_ITEMS');

348: p_segment_name=>'Material Over-Capacity Penalty') = TRUE THEN
349:
350: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');
351: FND_MESSAGE.set_token('SEGMENT','Material Over-Capacity Penalty');
352: FND_MESSAGE.set_token('TABLE','MTL_SYSTEM_ITEMS');
353: msgbuf := FND_MESSAGE.get;
354: LOG_MESSAGE(msgbuf);
355:
356: ELSE

Line 353: msgbuf := FND_MESSAGE.get;

349:
350: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');
351: FND_MESSAGE.set_token('SEGMENT','Material Over-Capacity Penalty');
352: FND_MESSAGE.set_token('TABLE','MTL_SYSTEM_ITEMS');
353: msgbuf := FND_MESSAGE.get;
354: LOG_MESSAGE(msgbuf);
355:
356: ELSE
357:

Line 408: FND_MESSAGE.set_name('MSC','MSC_ATTRIBUTE_EXISTS');

404: p_table_name => 'MTL_PARAMETERS',
405: p_column_name => 'ATTRIBUTE'||to_char(org_attr1),
406: x_message => msgbuf) = TRUE THEN
407:
408: FND_MESSAGE.set_name('MSC','MSC_ATTRIBUTE_EXISTS');
409: FND_MESSAGE.set_token('ATTRIBUTE','ATTRIBUTE'||to_char(org_attr1));
410: FND_MESSAGE.set_token('TABLE','MTL_PARAMETERS');
411: msgbuf := FND_MESSAGE.get;
412: LOG_MESSAGE(msgbuf);

Line 409: FND_MESSAGE.set_token('ATTRIBUTE','ATTRIBUTE'||to_char(org_attr1));

405: p_column_name => 'ATTRIBUTE'||to_char(org_attr1),
406: x_message => msgbuf) = TRUE THEN
407:
408: FND_MESSAGE.set_name('MSC','MSC_ATTRIBUTE_EXISTS');
409: FND_MESSAGE.set_token('ATTRIBUTE','ATTRIBUTE'||to_char(org_attr1));
410: FND_MESSAGE.set_token('TABLE','MTL_PARAMETERS');
411: msgbuf := FND_MESSAGE.get;
412: LOG_MESSAGE(msgbuf);
413:

Line 410: FND_MESSAGE.set_token('TABLE','MTL_PARAMETERS');

406: x_message => msgbuf) = TRUE THEN
407:
408: FND_MESSAGE.set_name('MSC','MSC_ATTRIBUTE_EXISTS');
409: FND_MESSAGE.set_token('ATTRIBUTE','ATTRIBUTE'||to_char(org_attr1));
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(

Line 411: msgbuf := FND_MESSAGE.get;

407:
408: FND_MESSAGE.set_name('MSC','MSC_ATTRIBUTE_EXISTS');
409: FND_MESSAGE.set_token('ATTRIBUTE','ATTRIBUTE'||to_char(org_attr1));
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',

Line 420: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');

416: p_flexfield_name=>'MTL_PARAMETERS',
417: p_context_code=>'Global Data Elements',
418: p_segment_name=>'Late Demands Penalty') = TRUE THEN
419:
420: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');
421: FND_MESSAGE.set_token('SEGMENT','Late Demands Penalty');
422: FND_MESSAGE.set_token('TABLE','MTL_PARAMETERS');
423: msgbuf := FND_MESSAGE.get;
424: LOG_MESSAGE(msgbuf);

Line 421: FND_MESSAGE.set_token('SEGMENT','Late Demands Penalty');

417: p_context_code=>'Global Data Elements',
418: p_segment_name=>'Late Demands Penalty') = TRUE THEN
419:
420: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');
421: FND_MESSAGE.set_token('SEGMENT','Late Demands Penalty');
422: FND_MESSAGE.set_token('TABLE','MTL_PARAMETERS');
423: msgbuf := FND_MESSAGE.get;
424: LOG_MESSAGE(msgbuf);
425:

Line 422: FND_MESSAGE.set_token('TABLE','MTL_PARAMETERS');

418: p_segment_name=>'Late Demands Penalty') = TRUE THEN
419:
420: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');
421: FND_MESSAGE.set_token('SEGMENT','Late Demands Penalty');
422: FND_MESSAGE.set_token('TABLE','MTL_PARAMETERS');
423: msgbuf := FND_MESSAGE.get;
424: LOG_MESSAGE(msgbuf);
425:
426: ELSE

Line 423: msgbuf := FND_MESSAGE.get;

419:
420: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');
421: FND_MESSAGE.set_token('SEGMENT','Late Demands Penalty');
422: FND_MESSAGE.set_token('TABLE','MTL_PARAMETERS');
423: msgbuf := FND_MESSAGE.get;
424: LOG_MESSAGE(msgbuf);
425:
426: ELSE
427:

Line 473: FND_MESSAGE.set_name('MSC','MSC_ATTRIBUTE_EXISTS');

469: p_table_name => 'MTL_PARAMETERS',
470: p_column_name => 'ATTRIBUTE'||to_char(org_attr2),
471: x_message => msgbuf) = TRUE THEN
472:
473: FND_MESSAGE.set_name('MSC','MSC_ATTRIBUTE_EXISTS');
474: FND_MESSAGE.set_token('ATTRIBUTE','ATTRIBUTE'||to_char(org_attr2));
475: FND_MESSAGE.set_token('TABLE','MTL_PARAMETERS');
476: msgbuf := FND_MESSAGE.get;
477: LOG_MESSAGE(msgbuf);

Line 474: FND_MESSAGE.set_token('ATTRIBUTE','ATTRIBUTE'||to_char(org_attr2));

470: p_column_name => 'ATTRIBUTE'||to_char(org_attr2),
471: x_message => msgbuf) = TRUE THEN
472:
473: FND_MESSAGE.set_name('MSC','MSC_ATTRIBUTE_EXISTS');
474: FND_MESSAGE.set_token('ATTRIBUTE','ATTRIBUTE'||to_char(org_attr2));
475: FND_MESSAGE.set_token('TABLE','MTL_PARAMETERS');
476: msgbuf := FND_MESSAGE.get;
477: LOG_MESSAGE(msgbuf);
478:

Line 475: FND_MESSAGE.set_token('TABLE','MTL_PARAMETERS');

471: x_message => msgbuf) = TRUE THEN
472:
473: FND_MESSAGE.set_name('MSC','MSC_ATTRIBUTE_EXISTS');
474: FND_MESSAGE.set_token('ATTRIBUTE','ATTRIBUTE'||to_char(org_attr2));
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(

Line 476: msgbuf := FND_MESSAGE.get;

472:
473: FND_MESSAGE.set_name('MSC','MSC_ATTRIBUTE_EXISTS');
474: FND_MESSAGE.set_token('ATTRIBUTE','ATTRIBUTE'||to_char(org_attr2));
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',

Line 485: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');

481: p_flexfield_name=>'MTL_PARAMETERS',
482: p_context_code=>'Global Data Elements',
483: p_segment_name=>'Material Over-Capacity Penalty') = TRUE THEN
484:
485: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');
486: FND_MESSAGE.set_token('SEGMENT','Material Over-Capacity Penalty');
487: FND_MESSAGE.set_token('TABLE','MTL_PARAMETERS');
488: msgbuf := FND_MESSAGE.get;
489: LOG_MESSAGE(msgbuf);

Line 486: FND_MESSAGE.set_token('SEGMENT','Material Over-Capacity Penalty');

482: p_context_code=>'Global Data Elements',
483: p_segment_name=>'Material Over-Capacity Penalty') = TRUE THEN
484:
485: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');
486: FND_MESSAGE.set_token('SEGMENT','Material Over-Capacity Penalty');
487: FND_MESSAGE.set_token('TABLE','MTL_PARAMETERS');
488: msgbuf := FND_MESSAGE.get;
489: LOG_MESSAGE(msgbuf);
490:

Line 487: FND_MESSAGE.set_token('TABLE','MTL_PARAMETERS');

483: p_segment_name=>'Material Over-Capacity Penalty') = TRUE THEN
484:
485: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');
486: FND_MESSAGE.set_token('SEGMENT','Material Over-Capacity Penalty');
487: FND_MESSAGE.set_token('TABLE','MTL_PARAMETERS');
488: msgbuf := FND_MESSAGE.get;
489: LOG_MESSAGE(msgbuf);
490:
491: ELSE

Line 488: msgbuf := FND_MESSAGE.get;

484:
485: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');
486: FND_MESSAGE.set_token('SEGMENT','Material Over-Capacity Penalty');
487: FND_MESSAGE.set_token('TABLE','MTL_PARAMETERS');
488: msgbuf := FND_MESSAGE.get;
489: LOG_MESSAGE(msgbuf);
490:
491: ELSE
492:

Line 538: FND_MESSAGE.set_name('MSC','MSC_ATTRIBUTE_EXISTS');

534: p_table_name => 'MTL_PARAMETERS',
535: p_column_name => 'ATTRIBUTE'||to_char(org_attr3),
536: x_message => msgbuf) = TRUE THEN
537:
538: FND_MESSAGE.set_name('MSC','MSC_ATTRIBUTE_EXISTS');
539: FND_MESSAGE.set_token('ATTRIBUTE','ATTRIBUTE'||to_char(org_attr3));
540: FND_MESSAGE.set_token('TABLE','MTL_PARAMETERS');
541: msgbuf := FND_MESSAGE.get;
542: LOG_MESSAGE(msgbuf);

Line 539: FND_MESSAGE.set_token('ATTRIBUTE','ATTRIBUTE'||to_char(org_attr3));

535: p_column_name => 'ATTRIBUTE'||to_char(org_attr3),
536: x_message => msgbuf) = TRUE THEN
537:
538: FND_MESSAGE.set_name('MSC','MSC_ATTRIBUTE_EXISTS');
539: FND_MESSAGE.set_token('ATTRIBUTE','ATTRIBUTE'||to_char(org_attr3));
540: FND_MESSAGE.set_token('TABLE','MTL_PARAMETERS');
541: msgbuf := FND_MESSAGE.get;
542: LOG_MESSAGE(msgbuf);
543:

Line 540: FND_MESSAGE.set_token('TABLE','MTL_PARAMETERS');

536: x_message => msgbuf) = TRUE THEN
537:
538: FND_MESSAGE.set_name('MSC','MSC_ATTRIBUTE_EXISTS');
539: FND_MESSAGE.set_token('ATTRIBUTE','ATTRIBUTE'||to_char(org_attr3));
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(

Line 541: msgbuf := FND_MESSAGE.get;

537:
538: FND_MESSAGE.set_name('MSC','MSC_ATTRIBUTE_EXISTS');
539: FND_MESSAGE.set_token('ATTRIBUTE','ATTRIBUTE'||to_char(org_attr3));
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',

Line 550: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');

546: p_flexfield_name=>'MTL_PARAMETERS',
547: p_context_code=>'Global Data Elements',
548: p_segment_name=>'Resource Over-Capacity Penalty') = TRUE THEN
549:
550: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');
551: FND_MESSAGE.set_token('SEGMENT','Resource Over-Capacity Penalty');
552: FND_MESSAGE.set_token('TABLE','MTL_PARAMETERS');
553: msgbuf := FND_MESSAGE.get;
554: LOG_MESSAGE(msgbuf);

Line 551: FND_MESSAGE.set_token('SEGMENT','Resource Over-Capacity Penalty');

547: p_context_code=>'Global Data Elements',
548: p_segment_name=>'Resource Over-Capacity Penalty') = TRUE THEN
549:
550: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');
551: FND_MESSAGE.set_token('SEGMENT','Resource Over-Capacity Penalty');
552: FND_MESSAGE.set_token('TABLE','MTL_PARAMETERS');
553: msgbuf := FND_MESSAGE.get;
554: LOG_MESSAGE(msgbuf);
555:

Line 552: FND_MESSAGE.set_token('TABLE','MTL_PARAMETERS');

548: p_segment_name=>'Resource Over-Capacity Penalty') = TRUE THEN
549:
550: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');
551: FND_MESSAGE.set_token('SEGMENT','Resource Over-Capacity Penalty');
552: FND_MESSAGE.set_token('TABLE','MTL_PARAMETERS');
553: msgbuf := FND_MESSAGE.get;
554: LOG_MESSAGE(msgbuf);
555:
556: ELSE

Line 553: msgbuf := FND_MESSAGE.get;

549:
550: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');
551: FND_MESSAGE.set_token('SEGMENT','Resource Over-Capacity Penalty');
552: FND_MESSAGE.set_token('TABLE','MTL_PARAMETERS');
553: msgbuf := FND_MESSAGE.get;
554: LOG_MESSAGE(msgbuf);
555:
556: ELSE
557:

Line 604: FND_MESSAGE.set_name('MSC','MSC_ATTRIBUTE_EXISTS');

600: p_table_name => 'MTL_PARAMETERS',
601: p_column_name => 'ATTRIBUTE'||to_char(org_attr4),
602: x_message => msgbuf) = TRUE THEN
603:
604: FND_MESSAGE.set_name('MSC','MSC_ATTRIBUTE_EXISTS');
605: FND_MESSAGE.set_token('ATTRIBUTE','ATTRIBUTE'||to_char(org_attr4));
606: FND_MESSAGE.set_token('TABLE','MTL_PARAMETERS');
607: msgbuf := FND_MESSAGE.get;
608: LOG_MESSAGE(msgbuf);

Line 605: FND_MESSAGE.set_token('ATTRIBUTE','ATTRIBUTE'||to_char(org_attr4));

601: p_column_name => 'ATTRIBUTE'||to_char(org_attr4),
602: x_message => msgbuf) = TRUE THEN
603:
604: FND_MESSAGE.set_name('MSC','MSC_ATTRIBUTE_EXISTS');
605: FND_MESSAGE.set_token('ATTRIBUTE','ATTRIBUTE'||to_char(org_attr4));
606: FND_MESSAGE.set_token('TABLE','MTL_PARAMETERS');
607: msgbuf := FND_MESSAGE.get;
608: LOG_MESSAGE(msgbuf);
609:

Line 606: FND_MESSAGE.set_token('TABLE','MTL_PARAMETERS');

602: x_message => msgbuf) = TRUE THEN
603:
604: FND_MESSAGE.set_name('MSC','MSC_ATTRIBUTE_EXISTS');
605: FND_MESSAGE.set_token('ATTRIBUTE','ATTRIBUTE'||to_char(org_attr4));
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(

Line 607: msgbuf := FND_MESSAGE.get;

603:
604: FND_MESSAGE.set_name('MSC','MSC_ATTRIBUTE_EXISTS');
605: FND_MESSAGE.set_token('ATTRIBUTE','ATTRIBUTE'||to_char(org_attr4));
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',

Line 616: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');

612: p_flexfield_name=>'MTL_PARAMETERS',
613: p_context_code=>'Global Data Elements',
614: p_segment_name=>'Transport Over-Cap Penalty') = TRUE THEN
615:
616: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');
617: FND_MESSAGE.set_token('SEGMENT','Transport Over-Cap Penalty');
618: FND_MESSAGE.set_token('TABLE','MTL_PARAMETERS');
619: msgbuf := FND_MESSAGE.get;
620: LOG_MESSAGE(msgbuf);

Line 617: FND_MESSAGE.set_token('SEGMENT','Transport Over-Cap Penalty');

613: p_context_code=>'Global Data Elements',
614: p_segment_name=>'Transport Over-Cap Penalty') = TRUE THEN
615:
616: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');
617: FND_MESSAGE.set_token('SEGMENT','Transport Over-Cap Penalty');
618: FND_MESSAGE.set_token('TABLE','MTL_PARAMETERS');
619: msgbuf := FND_MESSAGE.get;
620: LOG_MESSAGE(msgbuf);
621:

Line 618: FND_MESSAGE.set_token('TABLE','MTL_PARAMETERS');

614: p_segment_name=>'Transport Over-Cap Penalty') = TRUE THEN
615:
616: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');
617: FND_MESSAGE.set_token('SEGMENT','Transport Over-Cap Penalty');
618: FND_MESSAGE.set_token('TABLE','MTL_PARAMETERS');
619: msgbuf := FND_MESSAGE.get;
620: LOG_MESSAGE(msgbuf);
621:
622: ELSE

Line 619: msgbuf := FND_MESSAGE.get;

615:
616: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');
617: FND_MESSAGE.set_token('SEGMENT','Transport Over-Cap Penalty');
618: FND_MESSAGE.set_token('TABLE','MTL_PARAMETERS');
619: msgbuf := FND_MESSAGE.get;
620: LOG_MESSAGE(msgbuf);
621:
622: ELSE
623:

Line 676: FND_MESSAGE.set_name('MSC','MSC_ATTRIBUTE_EXISTS');

672: p_table_name => 'BOM_DEPARTMENT_RESOURCES',
673: p_column_name => 'ATTRIBUTE'||to_char(dept_attr1),
674: x_message => msgbuf) = TRUE THEN
675:
676: FND_MESSAGE.set_name('MSC','MSC_ATTRIBUTE_EXISTS');
677: FND_MESSAGE.set_token('ATTRIBUTE','ATTRIBUTE'||to_char(dept_attr1));
678: FND_MESSAGE.set_token('TABLE','BOM_DEPARTMENT_RESOURCES');
679: msgbuf := FND_MESSAGE.get;
680: LOG_MESSAGE(msgbuf);

Line 677: FND_MESSAGE.set_token('ATTRIBUTE','ATTRIBUTE'||to_char(dept_attr1));

673: p_column_name => 'ATTRIBUTE'||to_char(dept_attr1),
674: x_message => msgbuf) = TRUE THEN
675:
676: FND_MESSAGE.set_name('MSC','MSC_ATTRIBUTE_EXISTS');
677: FND_MESSAGE.set_token('ATTRIBUTE','ATTRIBUTE'||to_char(dept_attr1));
678: FND_MESSAGE.set_token('TABLE','BOM_DEPARTMENT_RESOURCES');
679: msgbuf := FND_MESSAGE.get;
680: LOG_MESSAGE(msgbuf);
681:

Line 678: FND_MESSAGE.set_token('TABLE','BOM_DEPARTMENT_RESOURCES');

674: x_message => msgbuf) = TRUE THEN
675:
676: FND_MESSAGE.set_name('MSC','MSC_ATTRIBUTE_EXISTS');
677: FND_MESSAGE.set_token('ATTRIBUTE','ATTRIBUTE'||to_char(dept_attr1));
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(

Line 679: msgbuf := FND_MESSAGE.get;

675:
676: FND_MESSAGE.set_name('MSC','MSC_ATTRIBUTE_EXISTS');
677: FND_MESSAGE.set_token('ATTRIBUTE','ATTRIBUTE'||to_char(dept_attr1));
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',

Line 688: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');

684: p_flexfield_name=>'BOM_DEPARTMENT_RESOURCES',
685: p_context_code=>'Global Data Elements',
686: p_segment_name=>'Aggregate Resource') = TRUE THEN
687:
688: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');
689: FND_MESSAGE.set_token('SEGMENT','Aggregate Resource');
690: FND_MESSAGE.set_token('TABLE','BOM_DEPARTMENT_RESOURCES');
691: msgbuf := FND_MESSAGE.get;
692: LOG_MESSAGE(msgbuf);

Line 689: FND_MESSAGE.set_token('SEGMENT','Aggregate Resource');

685: p_context_code=>'Global Data Elements',
686: p_segment_name=>'Aggregate Resource') = TRUE THEN
687:
688: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');
689: FND_MESSAGE.set_token('SEGMENT','Aggregate Resource');
690: FND_MESSAGE.set_token('TABLE','BOM_DEPARTMENT_RESOURCES');
691: msgbuf := FND_MESSAGE.get;
692: LOG_MESSAGE(msgbuf);
693:

Line 690: FND_MESSAGE.set_token('TABLE','BOM_DEPARTMENT_RESOURCES');

686: p_segment_name=>'Aggregate Resource') = TRUE THEN
687:
688: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');
689: FND_MESSAGE.set_token('SEGMENT','Aggregate Resource');
690: FND_MESSAGE.set_token('TABLE','BOM_DEPARTMENT_RESOURCES');
691: msgbuf := FND_MESSAGE.get;
692: LOG_MESSAGE(msgbuf);
693:
694: ELSE

Line 691: msgbuf := FND_MESSAGE.get;

687:
688: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');
689: FND_MESSAGE.set_token('SEGMENT','Aggregate Resource');
690: FND_MESSAGE.set_token('TABLE','BOM_DEPARTMENT_RESOURCES');
691: msgbuf := FND_MESSAGE.get;
692: LOG_MESSAGE(msgbuf);
693:
694: ELSE
695:

Line 749: FND_MESSAGE.set_name('MSC','MSC_ATTRIBUTE_EXISTS');

745: p_table_name => 'BOM_DEPARTMENT_RESOURCES',
746: p_column_name => 'ATTRIBUTE'||to_char(dept_attr2),
747: x_message => msgbuf) = TRUE THEN
748:
749: FND_MESSAGE.set_name('MSC','MSC_ATTRIBUTE_EXISTS');
750: FND_MESSAGE.set_token('ATTRIBUTE','ATTRIBUTE'||to_char(dept_attr2));
751: FND_MESSAGE.set_token('TABLE','BOM_DEPARTMENT_RESOURCES');
752: msgbuf := FND_MESSAGE.get;
753: LOG_MESSAGE(msgbuf);

Line 750: FND_MESSAGE.set_token('ATTRIBUTE','ATTRIBUTE'||to_char(dept_attr2));

746: p_column_name => 'ATTRIBUTE'||to_char(dept_attr2),
747: x_message => msgbuf) = TRUE THEN
748:
749: FND_MESSAGE.set_name('MSC','MSC_ATTRIBUTE_EXISTS');
750: FND_MESSAGE.set_token('ATTRIBUTE','ATTRIBUTE'||to_char(dept_attr2));
751: FND_MESSAGE.set_token('TABLE','BOM_DEPARTMENT_RESOURCES');
752: msgbuf := FND_MESSAGE.get;
753: LOG_MESSAGE(msgbuf);
754:

Line 751: FND_MESSAGE.set_token('TABLE','BOM_DEPARTMENT_RESOURCES');

747: x_message => msgbuf) = TRUE THEN
748:
749: FND_MESSAGE.set_name('MSC','MSC_ATTRIBUTE_EXISTS');
750: FND_MESSAGE.set_token('ATTRIBUTE','ATTRIBUTE'||to_char(dept_attr2));
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(

Line 752: msgbuf := FND_MESSAGE.get;

748:
749: FND_MESSAGE.set_name('MSC','MSC_ATTRIBUTE_EXISTS');
750: FND_MESSAGE.set_token('ATTRIBUTE','ATTRIBUTE'||to_char(dept_attr2));
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',

Line 761: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');

757: p_flexfield_name=>'BOM_DEPARTMENT_RESOURCES',
758: p_context_code=>'Global Data Elements',
759: p_segment_name=>'Resource Over-Capacity Penalty') = TRUE THEN
760:
761: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');
762: FND_MESSAGE.set_token('SEGMENT','Resource Over-Capacity Penalty');
763: FND_MESSAGE.set_token('TABLE','BOM_DEPARTMENT_RESOURCES');
764: msgbuf := FND_MESSAGE.get;
765: LOG_MESSAGE(msgbuf);

Line 762: FND_MESSAGE.set_token('SEGMENT','Resource Over-Capacity Penalty');

758: p_context_code=>'Global Data Elements',
759: p_segment_name=>'Resource Over-Capacity Penalty') = TRUE THEN
760:
761: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');
762: FND_MESSAGE.set_token('SEGMENT','Resource Over-Capacity Penalty');
763: FND_MESSAGE.set_token('TABLE','BOM_DEPARTMENT_RESOURCES');
764: msgbuf := FND_MESSAGE.get;
765: LOG_MESSAGE(msgbuf);
766:

Line 763: FND_MESSAGE.set_token('TABLE','BOM_DEPARTMENT_RESOURCES');

759: p_segment_name=>'Resource Over-Capacity Penalty') = TRUE THEN
760:
761: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');
762: FND_MESSAGE.set_token('SEGMENT','Resource Over-Capacity Penalty');
763: FND_MESSAGE.set_token('TABLE','BOM_DEPARTMENT_RESOURCES');
764: msgbuf := FND_MESSAGE.get;
765: LOG_MESSAGE(msgbuf);
766:
767: ELSE

Line 764: msgbuf := FND_MESSAGE.get;

760:
761: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');
762: FND_MESSAGE.set_token('SEGMENT','Resource Over-Capacity Penalty');
763: FND_MESSAGE.set_token('TABLE','BOM_DEPARTMENT_RESOURCES');
764: msgbuf := FND_MESSAGE.get;
765: LOG_MESSAGE(msgbuf);
766:
767: ELSE
768:

Line 819: FND_MESSAGE.set_name('MSC','MSC_ATTRIBUTE_EXISTS');

815: p_table_name => 'PO_ASL_ATTRIBUTES',
816: p_column_name => 'ATTRIBUTE'||to_char(supp_attr1),
817: x_message => msgbuf) = TRUE THEN
818:
819: FND_MESSAGE.set_name('MSC','MSC_ATTRIBUTE_EXISTS');
820: FND_MESSAGE.set_token('ATTRIBUTE','ATTRIBUTE'||to_char(supp_attr1));
821: FND_MESSAGE.set_token('TABLE','PO_ASL_ATTRIBUTES');
822: msgbuf := FND_MESSAGE.get;
823: LOG_MESSAGE(msgbuf);

Line 820: FND_MESSAGE.set_token('ATTRIBUTE','ATTRIBUTE'||to_char(supp_attr1));

816: p_column_name => 'ATTRIBUTE'||to_char(supp_attr1),
817: x_message => msgbuf) = TRUE THEN
818:
819: FND_MESSAGE.set_name('MSC','MSC_ATTRIBUTE_EXISTS');
820: FND_MESSAGE.set_token('ATTRIBUTE','ATTRIBUTE'||to_char(supp_attr1));
821: FND_MESSAGE.set_token('TABLE','PO_ASL_ATTRIBUTES');
822: msgbuf := FND_MESSAGE.get;
823: LOG_MESSAGE(msgbuf);
824:

Line 821: FND_MESSAGE.set_token('TABLE','PO_ASL_ATTRIBUTES');

817: x_message => msgbuf) = TRUE THEN
818:
819: FND_MESSAGE.set_name('MSC','MSC_ATTRIBUTE_EXISTS');
820: FND_MESSAGE.set_token('ATTRIBUTE','ATTRIBUTE'||to_char(supp_attr1));
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(

Line 822: msgbuf := FND_MESSAGE.get;

818:
819: FND_MESSAGE.set_name('MSC','MSC_ATTRIBUTE_EXISTS');
820: FND_MESSAGE.set_token('ATTRIBUTE','ATTRIBUTE'||to_char(supp_attr1));
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',

Line 831: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');

827: p_flexfield_name=>'PO_ASL_ATTRIBUTES',
828: p_context_code=>'Global Data Elements',
829: p_segment_name=>'Material Over-Capacity Penalty') = TRUE THEN
830:
831: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');
832: FND_MESSAGE.set_token('SEGMENT','Material Over-Capacity Penalty');
833: FND_MESSAGE.set_token('TABLE','PO_ASL_ATTRIBUTES');
834: msgbuf := FND_MESSAGE.get;
835: LOG_MESSAGE(msgbuf);

Line 832: FND_MESSAGE.set_token('SEGMENT','Material Over-Capacity Penalty');

828: p_context_code=>'Global Data Elements',
829: p_segment_name=>'Material Over-Capacity Penalty') = TRUE THEN
830:
831: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');
832: FND_MESSAGE.set_token('SEGMENT','Material Over-Capacity Penalty');
833: FND_MESSAGE.set_token('TABLE','PO_ASL_ATTRIBUTES');
834: msgbuf := FND_MESSAGE.get;
835: LOG_MESSAGE(msgbuf);
836:

Line 833: FND_MESSAGE.set_token('TABLE','PO_ASL_ATTRIBUTES');

829: p_segment_name=>'Material Over-Capacity Penalty') = TRUE THEN
830:
831: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');
832: FND_MESSAGE.set_token('SEGMENT','Material Over-Capacity Penalty');
833: FND_MESSAGE.set_token('TABLE','PO_ASL_ATTRIBUTES');
834: msgbuf := FND_MESSAGE.get;
835: LOG_MESSAGE(msgbuf);
836:
837: ELSE

Line 834: msgbuf := FND_MESSAGE.get;

830:
831: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');
832: FND_MESSAGE.set_token('SEGMENT','Material Over-Capacity Penalty');
833: FND_MESSAGE.set_token('TABLE','PO_ASL_ATTRIBUTES');
834: msgbuf := FND_MESSAGE.get;
835: LOG_MESSAGE(msgbuf);
836:
837: ELSE
838:

Line 890: FND_MESSAGE.set_name('MSC','MSC_ATTRIBUTE_EXISTS');

886: p_table_name => 'BOM_SUBSTITUTE_COMPONENTS',
887: p_column_name => 'ATTRIBUTE'||to_char(subst_attr1),
888: x_message => msgbuf) = TRUE THEN
889:
890: FND_MESSAGE.set_name('MSC','MSC_ATTRIBUTE_EXISTS');
891: FND_MESSAGE.set_token('ATTRIBUTE','ATTRIBUTE'||to_char(subst_attr1));
892: FND_MESSAGE.set_token('TABLE','BOM_SUBSTITUTE_COMPONENTS');
893: msgbuf := FND_MESSAGE.get;
894: LOG_MESSAGE(msgbuf);

Line 891: FND_MESSAGE.set_token('ATTRIBUTE','ATTRIBUTE'||to_char(subst_attr1));

887: p_column_name => 'ATTRIBUTE'||to_char(subst_attr1),
888: x_message => msgbuf) = TRUE THEN
889:
890: FND_MESSAGE.set_name('MSC','MSC_ATTRIBUTE_EXISTS');
891: FND_MESSAGE.set_token('ATTRIBUTE','ATTRIBUTE'||to_char(subst_attr1));
892: FND_MESSAGE.set_token('TABLE','BOM_SUBSTITUTE_COMPONENTS');
893: msgbuf := FND_MESSAGE.get;
894: LOG_MESSAGE(msgbuf);
895:

Line 892: FND_MESSAGE.set_token('TABLE','BOM_SUBSTITUTE_COMPONENTS');

888: x_message => msgbuf) = TRUE THEN
889:
890: FND_MESSAGE.set_name('MSC','MSC_ATTRIBUTE_EXISTS');
891: FND_MESSAGE.set_token('ATTRIBUTE','ATTRIBUTE'||to_char(subst_attr1));
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(

Line 893: msgbuf := FND_MESSAGE.get;

889:
890: FND_MESSAGE.set_name('MSC','MSC_ATTRIBUTE_EXISTS');
891: FND_MESSAGE.set_token('ATTRIBUTE','ATTRIBUTE'||to_char(subst_attr1));
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',

Line 902: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');

898: p_flexfield_name=>'BOM_SUBSTITUTE_COMPONENTS',
899: p_context_code=>'Global Data Elements',
900: p_segment_name=>'Substitute Priority') = TRUE THEN
901:
902: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');
903: FND_MESSAGE.set_token('SEGMENT','Substitute Priority');
904: FND_MESSAGE.set_token('TABLE','BOM_SUBSTITUTE_COMPONENTS');
905: msgbuf := FND_MESSAGE.get;
906: LOG_MESSAGE(msgbuf);

Line 903: FND_MESSAGE.set_token('SEGMENT','Substitute Priority');

899: p_context_code=>'Global Data Elements',
900: p_segment_name=>'Substitute Priority') = TRUE THEN
901:
902: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');
903: FND_MESSAGE.set_token('SEGMENT','Substitute Priority');
904: FND_MESSAGE.set_token('TABLE','BOM_SUBSTITUTE_COMPONENTS');
905: msgbuf := FND_MESSAGE.get;
906: LOG_MESSAGE(msgbuf);
907:

Line 904: FND_MESSAGE.set_token('TABLE','BOM_SUBSTITUTE_COMPONENTS');

900: p_segment_name=>'Substitute Priority') = TRUE THEN
901:
902: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');
903: FND_MESSAGE.set_token('SEGMENT','Substitute Priority');
904: FND_MESSAGE.set_token('TABLE','BOM_SUBSTITUTE_COMPONENTS');
905: msgbuf := FND_MESSAGE.get;
906: LOG_MESSAGE(msgbuf);
907:
908: ELSE

Line 905: msgbuf := FND_MESSAGE.get;

901:
902: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');
903: FND_MESSAGE.set_token('SEGMENT','Substitute Priority');
904: FND_MESSAGE.set_token('TABLE','BOM_SUBSTITUTE_COMPONENTS');
905: msgbuf := FND_MESSAGE.get;
906: LOG_MESSAGE(msgbuf);
907:
908: ELSE
909:

Line 961: FND_MESSAGE.set_name('MSC','MSC_ATTRIBUTE_EXISTS');

957: p_table_name => 'MTL_INTERORG_SHIP_METHODS',
958: p_column_name => 'ATTRIBUTE'||to_char(trans_attr1),
959: x_message => msgbuf) = TRUE THEN
960:
961: FND_MESSAGE.set_name('MSC','MSC_ATTRIBUTE_EXISTS');
962: FND_MESSAGE.set_token('ATTRIBUTE','ATTRIBUTE'||to_char(trans_attr1));
963: FND_MESSAGE.set_token('TABLE','MTL_INTERORG_SHIP_METHODS');
964: msgbuf := FND_MESSAGE.get;
965: LOG_MESSAGE(msgbuf);

Line 962: FND_MESSAGE.set_token('ATTRIBUTE','ATTRIBUTE'||to_char(trans_attr1));

958: p_column_name => 'ATTRIBUTE'||to_char(trans_attr1),
959: x_message => msgbuf) = TRUE THEN
960:
961: FND_MESSAGE.set_name('MSC','MSC_ATTRIBUTE_EXISTS');
962: FND_MESSAGE.set_token('ATTRIBUTE','ATTRIBUTE'||to_char(trans_attr1));
963: FND_MESSAGE.set_token('TABLE','MTL_INTERORG_SHIP_METHODS');
964: msgbuf := FND_MESSAGE.get;
965: LOG_MESSAGE(msgbuf);
966:

Line 963: FND_MESSAGE.set_token('TABLE','MTL_INTERORG_SHIP_METHODS');

959: x_message => msgbuf) = TRUE THEN
960:
961: FND_MESSAGE.set_name('MSC','MSC_ATTRIBUTE_EXISTS');
962: FND_MESSAGE.set_token('ATTRIBUTE','ATTRIBUTE'||to_char(trans_attr1));
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(

Line 964: msgbuf := FND_MESSAGE.get;

960:
961: FND_MESSAGE.set_name('MSC','MSC_ATTRIBUTE_EXISTS');
962: FND_MESSAGE.set_token('ATTRIBUTE','ATTRIBUTE'||to_char(trans_attr1));
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',

Line 973: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');

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
972:
973: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');
974: FND_MESSAGE.set_token('SEGMENT','Transport Over-Cap Penalty');
975: FND_MESSAGE.set_token('TABLE','MTL_INTERORG_SHIP_METHODS');
976: msgbuf := FND_MESSAGE.get;
977: LOG_MESSAGE(msgbuf);

Line 974: FND_MESSAGE.set_token('SEGMENT','Transport Over-Cap Penalty');

970: p_context_code=>'Global Data Elements',
971: p_segment_name=>'Transport Over-Cap Penalty') = TRUE THEN
972:
973: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');
974: FND_MESSAGE.set_token('SEGMENT','Transport Over-Cap Penalty');
975: FND_MESSAGE.set_token('TABLE','MTL_INTERORG_SHIP_METHODS');
976: msgbuf := FND_MESSAGE.get;
977: LOG_MESSAGE(msgbuf);
978:

Line 975: FND_MESSAGE.set_token('TABLE','MTL_INTERORG_SHIP_METHODS');

971: p_segment_name=>'Transport Over-Cap Penalty') = TRUE THEN
972:
973: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');
974: FND_MESSAGE.set_token('SEGMENT','Transport Over-Cap Penalty');
975: FND_MESSAGE.set_token('TABLE','MTL_INTERORG_SHIP_METHODS');
976: msgbuf := FND_MESSAGE.get;
977: LOG_MESSAGE(msgbuf);
978:
979: ELSE

Line 976: msgbuf := FND_MESSAGE.get;

972:
973: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');
974: FND_MESSAGE.set_token('SEGMENT','Transport Over-Cap Penalty');
975: FND_MESSAGE.set_token('TABLE','MTL_INTERORG_SHIP_METHODS');
976: msgbuf := FND_MESSAGE.get;
977: LOG_MESSAGE(msgbuf);
978:
979: ELSE
980:

Line 1032: FND_MESSAGE.set_name('MSC','MSC_ATTRIBUTE_EXISTS');

1028: p_table_name => 'BOM_BILL_OF_MATERIALS',
1029: p_column_name => 'ATTRIBUTE'||to_char(bom_attr1),
1030: x_message => msgbuf) = TRUE THEN
1031:
1032: FND_MESSAGE.set_name('MSC','MSC_ATTRIBUTE_EXISTS');
1033: FND_MESSAGE.set_token('ATTRIBUTE','ATTRIBUTE'||to_char(bom_attr1));
1034: FND_MESSAGE.set_token('TABLE','BOM_BILL_OF_MATERIALS');
1035: msgbuf := FND_MESSAGE.get;
1036: LOG_MESSAGE(msgbuf);

Line 1033: FND_MESSAGE.set_token('ATTRIBUTE','ATTRIBUTE'||to_char(bom_attr1));

1029: p_column_name => 'ATTRIBUTE'||to_char(bom_attr1),
1030: x_message => msgbuf) = TRUE THEN
1031:
1032: FND_MESSAGE.set_name('MSC','MSC_ATTRIBUTE_EXISTS');
1033: FND_MESSAGE.set_token('ATTRIBUTE','ATTRIBUTE'||to_char(bom_attr1));
1034: FND_MESSAGE.set_token('TABLE','BOM_BILL_OF_MATERIALS');
1035: msgbuf := FND_MESSAGE.get;
1036: LOG_MESSAGE(msgbuf);
1037:

Line 1034: FND_MESSAGE.set_token('TABLE','BOM_BILL_OF_MATERIALS');

1030: x_message => msgbuf) = TRUE THEN
1031:
1032: FND_MESSAGE.set_name('MSC','MSC_ATTRIBUTE_EXISTS');
1033: FND_MESSAGE.set_token('ATTRIBUTE','ATTRIBUTE'||to_char(bom_attr1));
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(

Line 1035: msgbuf := FND_MESSAGE.get;

1031:
1032: FND_MESSAGE.set_name('MSC','MSC_ATTRIBUTE_EXISTS');
1033: FND_MESSAGE.set_token('ATTRIBUTE','ATTRIBUTE'||to_char(bom_attr1));
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',

Line 1044: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');

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
1043:
1044: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');
1045: FND_MESSAGE.set_token('SEGMENT','Cost of Using a BOM/Routing');
1046: FND_MESSAGE.set_token('TABLE','BOM_BILL_OF_MATERIALS');
1047: msgbuf := FND_MESSAGE.get;
1048: LOG_MESSAGE(msgbuf);

Line 1045: FND_MESSAGE.set_token('SEGMENT','Cost of Using a BOM/Routing');

1041: p_context_code=>'Global Data Elements',
1042: p_segment_name=>'Cost of Using a BOM/Routing') = TRUE THEN
1043:
1044: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');
1045: FND_MESSAGE.set_token('SEGMENT','Cost of Using a BOM/Routing');
1046: FND_MESSAGE.set_token('TABLE','BOM_BILL_OF_MATERIALS');
1047: msgbuf := FND_MESSAGE.get;
1048: LOG_MESSAGE(msgbuf);
1049:

Line 1046: FND_MESSAGE.set_token('TABLE','BOM_BILL_OF_MATERIALS');

1042: p_segment_name=>'Cost of Using a BOM/Routing') = TRUE THEN
1043:
1044: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');
1045: FND_MESSAGE.set_token('SEGMENT','Cost of Using a BOM/Routing');
1046: FND_MESSAGE.set_token('TABLE','BOM_BILL_OF_MATERIALS');
1047: msgbuf := FND_MESSAGE.get;
1048: LOG_MESSAGE(msgbuf);
1049:
1050: ELSE

Line 1047: msgbuf := FND_MESSAGE.get;

1043:
1044: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');
1045: FND_MESSAGE.set_token('SEGMENT','Cost of Using a BOM/Routing');
1046: FND_MESSAGE.set_token('TABLE','BOM_BILL_OF_MATERIALS');
1047: msgbuf := FND_MESSAGE.get;
1048: LOG_MESSAGE(msgbuf);
1049:
1050: ELSE
1051:

Line 1103: FND_MESSAGE.set_name('MSC','MSC_ATTRIBUTE_EXISTS');

1099: p_table_name => 'MRP_FORECAST_DATES',
1100: p_column_name => 'ATTRIBUTE'||to_char(forecast_attr1),
1101: x_message => msgbuf) = TRUE THEN
1102:
1103: FND_MESSAGE.set_name('MSC','MSC_ATTRIBUTE_EXISTS');
1104: FND_MESSAGE.set_token('ATTRIBUTE','ATTRIBUTE'||to_char(forecast_attr1));
1105: FND_MESSAGE.set_token('TABLE','MRP_FORECAST_DATES');
1106: msgbuf := FND_MESSAGE.get;
1107: LOG_MESSAGE(msgbuf);

Line 1104: FND_MESSAGE.set_token('ATTRIBUTE','ATTRIBUTE'||to_char(forecast_attr1));

1100: p_column_name => 'ATTRIBUTE'||to_char(forecast_attr1),
1101: x_message => msgbuf) = TRUE THEN
1102:
1103: FND_MESSAGE.set_name('MSC','MSC_ATTRIBUTE_EXISTS');
1104: FND_MESSAGE.set_token('ATTRIBUTE','ATTRIBUTE'||to_char(forecast_attr1));
1105: FND_MESSAGE.set_token('TABLE','MRP_FORECAST_DATES');
1106: msgbuf := FND_MESSAGE.get;
1107: LOG_MESSAGE(msgbuf);
1108:

Line 1105: FND_MESSAGE.set_token('TABLE','MRP_FORECAST_DATES');

1101: x_message => msgbuf) = TRUE THEN
1102:
1103: FND_MESSAGE.set_name('MSC','MSC_ATTRIBUTE_EXISTS');
1104: FND_MESSAGE.set_token('ATTRIBUTE','ATTRIBUTE'||to_char(forecast_attr1));
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(

Line 1106: msgbuf := FND_MESSAGE.get;

1102:
1103: FND_MESSAGE.set_name('MSC','MSC_ATTRIBUTE_EXISTS');
1104: FND_MESSAGE.set_token('ATTRIBUTE','ATTRIBUTE'||to_char(forecast_attr1));
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',

Line 1115: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');

1111: p_flexfield_name=>'MRP_FORECAST_DATES',
1112: p_context_code=>'Global Data Elements',
1113: p_segment_name=>'Late Forecasts Penalty') = TRUE THEN
1114:
1115: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');
1116: FND_MESSAGE.set_token('SEGMENT','Late Forecasts Penalty');
1117: FND_MESSAGE.set_token('TABLE','MRP_FORECAST_DATES');
1118: msgbuf := FND_MESSAGE.get;
1119: LOG_MESSAGE(msgbuf);

Line 1116: FND_MESSAGE.set_token('SEGMENT','Late Forecasts Penalty');

1112: p_context_code=>'Global Data Elements',
1113: p_segment_name=>'Late Forecasts Penalty') = TRUE THEN
1114:
1115: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');
1116: FND_MESSAGE.set_token('SEGMENT','Late Forecasts Penalty');
1117: FND_MESSAGE.set_token('TABLE','MRP_FORECAST_DATES');
1118: msgbuf := FND_MESSAGE.get;
1119: LOG_MESSAGE(msgbuf);
1120:

Line 1117: FND_MESSAGE.set_token('TABLE','MRP_FORECAST_DATES');

1113: p_segment_name=>'Late Forecasts Penalty') = TRUE THEN
1114:
1115: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');
1116: FND_MESSAGE.set_token('SEGMENT','Late Forecasts Penalty');
1117: FND_MESSAGE.set_token('TABLE','MRP_FORECAST_DATES');
1118: msgbuf := FND_MESSAGE.get;
1119: LOG_MESSAGE(msgbuf);
1120:
1121: ELSE

Line 1118: msgbuf := FND_MESSAGE.get;

1114:
1115: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');
1116: FND_MESSAGE.set_token('SEGMENT','Late Forecasts Penalty');
1117: FND_MESSAGE.set_token('TABLE','MRP_FORECAST_DATES');
1118: msgbuf := FND_MESSAGE.get;
1119: LOG_MESSAGE(msgbuf);
1120:
1121: ELSE
1122:

Line 1173: FND_MESSAGE.set_name('MSC','MSC_ATTRIBUTE_EXISTS');

1169: p_table_name => 'WIP_LINES',
1170: p_column_name => 'ATTRIBUTE'||to_char(line_attr1),
1171: x_message => msgbuf) = TRUE THEN
1172:
1173: FND_MESSAGE.set_name('MSC','MSC_ATTRIBUTE_EXISTS');
1174: FND_MESSAGE.set_token('ATTRIBUTE','ATTRIBUTE'||to_char(line_attr1));
1175: FND_MESSAGE.set_token('TABLE','WIP_LINES');
1176: msgbuf := FND_MESSAGE.get;
1177: LOG_MESSAGE(msgbuf);

Line 1174: FND_MESSAGE.set_token('ATTRIBUTE','ATTRIBUTE'||to_char(line_attr1));

1170: p_column_name => 'ATTRIBUTE'||to_char(line_attr1),
1171: x_message => msgbuf) = TRUE THEN
1172:
1173: FND_MESSAGE.set_name('MSC','MSC_ATTRIBUTE_EXISTS');
1174: FND_MESSAGE.set_token('ATTRIBUTE','ATTRIBUTE'||to_char(line_attr1));
1175: FND_MESSAGE.set_token('TABLE','WIP_LINES');
1176: msgbuf := FND_MESSAGE.get;
1177: LOG_MESSAGE(msgbuf);
1178:

Line 1175: FND_MESSAGE.set_token('TABLE','WIP_LINES');

1171: x_message => msgbuf) = TRUE THEN
1172:
1173: FND_MESSAGE.set_name('MSC','MSC_ATTRIBUTE_EXISTS');
1174: FND_MESSAGE.set_token('ATTRIBUTE','ATTRIBUTE'||to_char(line_attr1));
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(

Line 1176: msgbuf := FND_MESSAGE.get;

1172:
1173: FND_MESSAGE.set_name('MSC','MSC_ATTRIBUTE_EXISTS');
1174: FND_MESSAGE.set_token('ATTRIBUTE','ATTRIBUTE'||to_char(line_attr1));
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',

Line 1185: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');

1181: p_flexfield_name=>'WIP_LINES',
1182: p_context_code=>'Global Data Elements',
1183: p_segment_name=>'Resource Group') = TRUE THEN
1184:
1185: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');
1186: FND_MESSAGE.set_token('SEGMENT','Resource Group');
1187: FND_MESSAGE.set_token('TABLE','WIP_LINES');
1188: msgbuf := FND_MESSAGE.get;
1189: LOG_MESSAGE(msgbuf);

Line 1186: FND_MESSAGE.set_token('SEGMENT','Resource Group');

1182: p_context_code=>'Global Data Elements',
1183: p_segment_name=>'Resource Group') = TRUE THEN
1184:
1185: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');
1186: FND_MESSAGE.set_token('SEGMENT','Resource Group');
1187: FND_MESSAGE.set_token('TABLE','WIP_LINES');
1188: msgbuf := FND_MESSAGE.get;
1189: LOG_MESSAGE(msgbuf);
1190:

Line 1187: FND_MESSAGE.set_token('TABLE','WIP_LINES');

1183: p_segment_name=>'Resource Group') = TRUE THEN
1184:
1185: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');
1186: FND_MESSAGE.set_token('SEGMENT','Resource Group');
1187: FND_MESSAGE.set_token('TABLE','WIP_LINES');
1188: msgbuf := FND_MESSAGE.get;
1189: LOG_MESSAGE(msgbuf);
1190:
1191: ELSE

Line 1188: msgbuf := FND_MESSAGE.get;

1184:
1185: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');
1186: FND_MESSAGE.set_token('SEGMENT','Resource Group');
1187: FND_MESSAGE.set_token('TABLE','WIP_LINES');
1188: msgbuf := FND_MESSAGE.get;
1189: LOG_MESSAGE(msgbuf);
1190:
1191: ELSE
1192:

Line 1240: FND_MESSAGE.set_name('MSC','MSC_ATTRIBUTE_EXISTS');

1236: p_table_name => 'MRP_SCHEDULE_DATES',
1237: p_column_name => 'ATTRIBUTE'||to_char(schedule_attr1),
1238: x_message => msgbuf) = TRUE THEN
1239:
1240: FND_MESSAGE.set_name('MSC','MSC_ATTRIBUTE_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);

Line 1241: FND_MESSAGE.set_token('ATTRIBUTE','ATTRIBUTE'||to_char(schedule_attr1));

1237: p_column_name => 'ATTRIBUTE'||to_char(schedule_attr1),
1238: x_message => msgbuf) = TRUE THEN
1239:
1240: FND_MESSAGE.set_name('MSC','MSC_ATTRIBUTE_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(

Line 1242: FND_MESSAGE.set_token('TABLE','MRP_SCHEDULE_DATES');

1238: x_message => msgbuf) = TRUE THEN
1239:
1240: FND_MESSAGE.set_name('MSC','MSC_ATTRIBUTE_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',

Line 1243: msgbuf := FND_MESSAGE.get;

1239:
1240: FND_MESSAGE.set_name('MSC','MSC_ATTRIBUTE_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',

Line 1251: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');

1247: p_flexfield_name=>'MRP_SCHEDULE_DATES',
1248: p_context_code=>'Global Data Elements',
1249: p_segment_name=>'Demand Priority') = TRUE THEN
1250:
1251: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');
1252: FND_MESSAGE.set_token('SEGMENT','Demand Priority');
1253: FND_MESSAGE.set_token('TABLE','MRP_SCHEDULE_DATES');
1254: msgbuf := FND_MESSAGE.get;
1255: LOG_MESSAGE(msgbuf);

Line 1252: FND_MESSAGE.set_token('SEGMENT','Demand Priority');

1248: p_context_code=>'Global Data Elements',
1249: p_segment_name=>'Demand Priority') = TRUE THEN
1250:
1251: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');
1252: FND_MESSAGE.set_token('SEGMENT','Demand Priority');
1253: FND_MESSAGE.set_token('TABLE','MRP_SCHEDULE_DATES');
1254: msgbuf := FND_MESSAGE.get;
1255: LOG_MESSAGE(msgbuf);
1256:

Line 1253: FND_MESSAGE.set_token('TABLE','MRP_SCHEDULE_DATES');

1249: p_segment_name=>'Demand Priority') = TRUE THEN
1250:
1251: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');
1252: FND_MESSAGE.set_token('SEGMENT','Demand Priority');
1253: FND_MESSAGE.set_token('TABLE','MRP_SCHEDULE_DATES');
1254: msgbuf := FND_MESSAGE.get;
1255: LOG_MESSAGE(msgbuf);
1256:
1257: ELSE

Line 1254: msgbuf := FND_MESSAGE.get;

1250:
1251: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');
1252: FND_MESSAGE.set_token('SEGMENT','Demand Priority');
1253: FND_MESSAGE.set_token('TABLE','MRP_SCHEDULE_DATES');
1254: msgbuf := FND_MESSAGE.get;
1255: LOG_MESSAGE(msgbuf);
1256:
1257: ELSE
1258: fnd_flex_dsc_api.create_segment(

Line 1387: substr(fnd_message.get,1,240);

1383: retcode := 0; -- success
1384: EXCEPTION
1385: WHEN conc_failure THEN
1386: errbuf := 'Error ' ||
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

Line 1427: FND_MESSAGE.set_name('MSC','MSC_ATTRIBUTE_EXISTS');

1423: p_table_name => 'OPERATION_RESOURCES',
1424: p_column_name => 'ATTRIBUTE'||to_char(oper_attr1),
1425: x_message => msgbuf) = TRUE THEN
1426:
1427: FND_MESSAGE.set_name('MSC','MSC_ATTRIBUTE_EXISTS');
1428: FND_MESSAGE.set_token('ATTRIBUTE','ATTRIBUTE'||to_char(oper_attr1));
1429: FND_MESSAGE.set_token('TABLE','OPERATION_RESOURCES');
1430: msgbuf := FND_MESSAGE.get;
1431: LOG_MESSAGE(msgbuf);

Line 1428: FND_MESSAGE.set_token('ATTRIBUTE','ATTRIBUTE'||to_char(oper_attr1));

1424: p_column_name => 'ATTRIBUTE'||to_char(oper_attr1),
1425: x_message => msgbuf) = TRUE THEN
1426:
1427: FND_MESSAGE.set_name('MSC','MSC_ATTRIBUTE_EXISTS');
1428: FND_MESSAGE.set_token('ATTRIBUTE','ATTRIBUTE'||to_char(oper_attr1));
1429: FND_MESSAGE.set_token('TABLE','OPERATION_RESOURCES');
1430: msgbuf := FND_MESSAGE.get;
1431: LOG_MESSAGE(msgbuf);
1432: ELSIF

Line 1429: FND_MESSAGE.set_token('TABLE','OPERATION_RESOURCES');

1425: x_message => msgbuf) = TRUE THEN
1426:
1427: FND_MESSAGE.set_name('MSC','MSC_ATTRIBUTE_EXISTS');
1428: FND_MESSAGE.set_token('ATTRIBUTE','ATTRIBUTE'||to_char(oper_attr1));
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(

Line 1430: msgbuf := FND_MESSAGE.get;

1426:
1427: FND_MESSAGE.set_name('MSC','MSC_ATTRIBUTE_EXISTS');
1428: FND_MESSAGE.set_token('ATTRIBUTE','ATTRIBUTE'||to_char(oper_attr1));
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',

Line 1438: FND_MESSAGE.set_name('MSC','MSC_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
1438: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');
1439: FND_MESSAGE.set_token('SEGMENT','Activity Group Id');
1440: FND_MESSAGE.set_token('TABLE','OPERATION_RESOURCES');
1441: msgbuf := FND_MESSAGE.get;
1442: LOG_MESSAGE(msgbuf);

Line 1439: FND_MESSAGE.set_token('SEGMENT','Activity Group Id');

1435: p_flexfield_name=>'OPERATION_RESOURCES',
1436: p_context_code=>'Global Data Elements',
1437: p_segment_name=>'Activity Group Id') = TRUE THEN
1438: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');
1439: FND_MESSAGE.set_token('SEGMENT','Activity Group Id');
1440: FND_MESSAGE.set_token('TABLE','OPERATION_RESOURCES');
1441: msgbuf := FND_MESSAGE.get;
1442: LOG_MESSAGE(msgbuf);
1443: ELSE

Line 1440: FND_MESSAGE.set_token('TABLE','OPERATION_RESOURCES');

1436: p_context_code=>'Global Data Elements',
1437: p_segment_name=>'Activity Group Id') = TRUE THEN
1438: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');
1439: FND_MESSAGE.set_token('SEGMENT','Activity Group Id');
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(

Line 1441: msgbuf := FND_MESSAGE.get;

1437: p_segment_name=>'Activity Group Id') = TRUE THEN
1438: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');
1439: FND_MESSAGE.set_token('SEGMENT','Activity Group Id');
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',

Line 1514: substr(fnd_message.get,1,240);

1510: EXCEPTION
1511:
1512: WHEN conc_failure THEN
1513: errbuf := 'Error ' ||
1514: substr(fnd_message.get,1,240);
1515: retcode := 2;
1516:
1517: WHEN OTHERS THEN
1518: rollback;

Line 1561: FND_MESSAGE.set_name('MSC','MSC_ATTRIBUTE_EXISTS');

1557: p_table_name => 'BOM_DEPARTMENT_RESOURCES',
1558: p_column_name => 'ATTRIBUTE'||to_char(bom_attr1),
1559: x_message => msgbuf) = TRUE THEN
1560:
1561: FND_MESSAGE.set_name('MSC','MSC_ATTRIBUTE_EXISTS');
1562: FND_MESSAGE.set_token('ATTRIBUTE','ATTRIBUTE'||to_char(bom_attr1));
1563: FND_MESSAGE.set_token('TABLE','BOM_DEPARTMENT_RESOURCES');
1564: msgbuf := FND_MESSAGE.get;
1565: LOG_MESSAGE(msgbuf);

Line 1562: FND_MESSAGE.set_token('ATTRIBUTE','ATTRIBUTE'||to_char(bom_attr1));

1558: p_column_name => 'ATTRIBUTE'||to_char(bom_attr1),
1559: x_message => msgbuf) = TRUE THEN
1560:
1561: FND_MESSAGE.set_name('MSC','MSC_ATTRIBUTE_EXISTS');
1562: FND_MESSAGE.set_token('ATTRIBUTE','ATTRIBUTE'||to_char(bom_attr1));
1563: FND_MESSAGE.set_token('TABLE','BOM_DEPARTMENT_RESOURCES');
1564: msgbuf := FND_MESSAGE.get;
1565: LOG_MESSAGE(msgbuf);
1566: ELSIF

Line 1563: FND_MESSAGE.set_token('TABLE','BOM_DEPARTMENT_RESOURCES');

1559: x_message => msgbuf) = TRUE THEN
1560:
1561: FND_MESSAGE.set_name('MSC','MSC_ATTRIBUTE_EXISTS');
1562: FND_MESSAGE.set_token('ATTRIBUTE','ATTRIBUTE'||to_char(bom_attr1));
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(

Line 1564: msgbuf := FND_MESSAGE.get;

1560:
1561: FND_MESSAGE.set_name('MSC','MSC_ATTRIBUTE_EXISTS');
1562: FND_MESSAGE.set_token('ATTRIBUTE','ATTRIBUTE'||to_char(bom_attr1));
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',

Line 1572: FND_MESSAGE.set_name('MSC','MSC_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
1572: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');
1573: FND_MESSAGE.set_token('SEGMENT','Batchable Flag');
1574: FND_MESSAGE.set_token('TABLE','BOM_DEPARTMENT_RESOURCES');
1575: msgbuf := FND_MESSAGE.get;
1576: LOG_MESSAGE(msgbuf);

Line 1573: FND_MESSAGE.set_token('SEGMENT','Batchable Flag');

1569: p_flexfield_name=>'BOM_DEPARTMENT_RESOURCES',
1570: p_context_code=>'Global Data Elements',
1571: p_segment_name=>'Batchable Flag') = TRUE THEN
1572: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');
1573: FND_MESSAGE.set_token('SEGMENT','Batchable Flag');
1574: FND_MESSAGE.set_token('TABLE','BOM_DEPARTMENT_RESOURCES');
1575: msgbuf := FND_MESSAGE.get;
1576: LOG_MESSAGE(msgbuf);
1577: ELSE

Line 1574: FND_MESSAGE.set_token('TABLE','BOM_DEPARTMENT_RESOURCES');

1570: p_context_code=>'Global Data Elements',
1571: p_segment_name=>'Batchable Flag') = TRUE THEN
1572: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');
1573: FND_MESSAGE.set_token('SEGMENT','Batchable Flag');
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(

Line 1575: msgbuf := FND_MESSAGE.get;

1571: p_segment_name=>'Batchable Flag') = TRUE THEN
1572: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');
1573: FND_MESSAGE.set_token('SEGMENT','Batchable Flag');
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',

Line 1622: FND_MESSAGE.set_name('MSC','MSC_ATTRIBUTE_EXISTS');

1618: p_table_name => 'BOM_DEPARTMENT_RESOURCES',
1619: p_column_name => 'ATTRIBUTE'||to_char(bom_attr2),
1620: x_message => msgbuf) = TRUE THEN
1621:
1622: FND_MESSAGE.set_name('MSC','MSC_ATTRIBUTE_EXISTS');
1623: FND_MESSAGE.set_token('ATTRIBUTE','ATTRIBUTE'||to_char(bom_attr2));
1624: FND_MESSAGE.set_token('TABLE','BOM_DEPARTMENT_RESOURCES');
1625: msgbuf := FND_MESSAGE.get;
1626: LOG_MESSAGE(msgbuf);

Line 1623: FND_MESSAGE.set_token('ATTRIBUTE','ATTRIBUTE'||to_char(bom_attr2));

1619: p_column_name => 'ATTRIBUTE'||to_char(bom_attr2),
1620: x_message => msgbuf) = TRUE THEN
1621:
1622: FND_MESSAGE.set_name('MSC','MSC_ATTRIBUTE_EXISTS');
1623: FND_MESSAGE.set_token('ATTRIBUTE','ATTRIBUTE'||to_char(bom_attr2));
1624: FND_MESSAGE.set_token('TABLE','BOM_DEPARTMENT_RESOURCES');
1625: msgbuf := FND_MESSAGE.get;
1626: LOG_MESSAGE(msgbuf);
1627: ELSIF

Line 1624: FND_MESSAGE.set_token('TABLE','BOM_DEPARTMENT_RESOURCES');

1620: x_message => msgbuf) = TRUE THEN
1621:
1622: FND_MESSAGE.set_name('MSC','MSC_ATTRIBUTE_EXISTS');
1623: FND_MESSAGE.set_token('ATTRIBUTE','ATTRIBUTE'||to_char(bom_attr2));
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(

Line 1625: msgbuf := FND_MESSAGE.get;

1621:
1622: FND_MESSAGE.set_name('MSC','MSC_ATTRIBUTE_EXISTS');
1623: FND_MESSAGE.set_token('ATTRIBUTE','ATTRIBUTE'||to_char(bom_attr2));
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',

Line 1633: FND_MESSAGE.set_name('MSC','MSC_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
1633: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');
1634: FND_MESSAGE.set_token('SEGMENT','Batching Window');
1635: FND_MESSAGE.set_token('TABLE','BOM_DEPARTMENT_RESOURCES');
1636: msgbuf := FND_MESSAGE.get;
1637: LOG_MESSAGE(msgbuf);

Line 1634: FND_MESSAGE.set_token('SEGMENT','Batching Window');

1630: p_flexfield_name=>'BOM_DEPARTMENT_RESOURCES',
1631: p_context_code=>'Global Data Elements',
1632: p_segment_name=>'Batching Window') = TRUE THEN
1633: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');
1634: FND_MESSAGE.set_token('SEGMENT','Batching Window');
1635: FND_MESSAGE.set_token('TABLE','BOM_DEPARTMENT_RESOURCES');
1636: msgbuf := FND_MESSAGE.get;
1637: LOG_MESSAGE(msgbuf);
1638: ELSE

Line 1635: FND_MESSAGE.set_token('TABLE','BOM_DEPARTMENT_RESOURCES');

1631: p_context_code=>'Global Data Elements',
1632: p_segment_name=>'Batching Window') = TRUE THEN
1633: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');
1634: FND_MESSAGE.set_token('SEGMENT','Batching Window');
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(

Line 1636: msgbuf := FND_MESSAGE.get;

1632: p_segment_name=>'Batching Window') = TRUE THEN
1633: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');
1634: FND_MESSAGE.set_token('SEGMENT','Batching Window');
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',

Line 1681: FND_MESSAGE.set_name('MSC','MSC_ATTRIBUTE_EXISTS');

1677: p_table_name => 'BOM_DEPARTMENT_RESOURCES',
1678: p_column_name => 'ATTRIBUTE'||to_char(bom_attr3),
1679: x_message => msgbuf) = TRUE THEN
1680:
1681: FND_MESSAGE.set_name('MSC','MSC_ATTRIBUTE_EXISTS');
1682: FND_MESSAGE.set_token('ATTRIBUTE','ATTRIBUTE'||to_char(bom_attr3));
1683: FND_MESSAGE.set_token('TABLE','BOM_DEPARTMENT_RESOURCES');
1684: msgbuf := FND_MESSAGE.get;
1685: LOG_MESSAGE(msgbuf);

Line 1682: FND_MESSAGE.set_token('ATTRIBUTE','ATTRIBUTE'||to_char(bom_attr3));

1678: p_column_name => 'ATTRIBUTE'||to_char(bom_attr3),
1679: x_message => msgbuf) = TRUE THEN
1680:
1681: FND_MESSAGE.set_name('MSC','MSC_ATTRIBUTE_EXISTS');
1682: FND_MESSAGE.set_token('ATTRIBUTE','ATTRIBUTE'||to_char(bom_attr3));
1683: FND_MESSAGE.set_token('TABLE','BOM_DEPARTMENT_RESOURCES');
1684: msgbuf := FND_MESSAGE.get;
1685: LOG_MESSAGE(msgbuf);
1686: ELSIF

Line 1683: FND_MESSAGE.set_token('TABLE','BOM_DEPARTMENT_RESOURCES');

1679: x_message => msgbuf) = TRUE THEN
1680:
1681: FND_MESSAGE.set_name('MSC','MSC_ATTRIBUTE_EXISTS');
1682: FND_MESSAGE.set_token('ATTRIBUTE','ATTRIBUTE'||to_char(bom_attr3));
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(

Line 1684: msgbuf := FND_MESSAGE.get;

1680:
1681: FND_MESSAGE.set_name('MSC','MSC_ATTRIBUTE_EXISTS');
1682: FND_MESSAGE.set_token('ATTRIBUTE','ATTRIBUTE'||to_char(bom_attr3));
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',

Line 1692: FND_MESSAGE.set_name('MSC','MSC_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
1692: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');
1693: FND_MESSAGE.set_token('SEGMENT','Minimum Batch Capacity');
1694: FND_MESSAGE.set_token('TABLE','BOM_DEPARTMENT_RESOURCES');
1695: msgbuf := FND_MESSAGE.get;
1696: LOG_MESSAGE(msgbuf);

Line 1693: FND_MESSAGE.set_token('SEGMENT','Minimum Batch Capacity');

1689: p_flexfield_name=>'BOM_DEPARTMENT_RESOURCES',
1690: p_context_code=>'Global Data Elements',
1691: p_segment_name=>'Minimum Batch Capacity') = TRUE THEN
1692: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');
1693: FND_MESSAGE.set_token('SEGMENT','Minimum Batch Capacity');
1694: FND_MESSAGE.set_token('TABLE','BOM_DEPARTMENT_RESOURCES');
1695: msgbuf := FND_MESSAGE.get;
1696: LOG_MESSAGE(msgbuf);
1697: ELSE

Line 1694: FND_MESSAGE.set_token('TABLE','BOM_DEPARTMENT_RESOURCES');

1690: p_context_code=>'Global Data Elements',
1691: p_segment_name=>'Minimum Batch Capacity') = TRUE THEN
1692: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');
1693: FND_MESSAGE.set_token('SEGMENT','Minimum Batch Capacity');
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(

Line 1695: msgbuf := FND_MESSAGE.get;

1691: p_segment_name=>'Minimum Batch Capacity') = TRUE THEN
1692: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');
1693: FND_MESSAGE.set_token('SEGMENT','Minimum Batch Capacity');
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',

Line 1740: FND_MESSAGE.set_name('MSC','MSC_ATTRIBUTE_EXISTS');

1736: p_table_name => 'BOM_DEPARTMENT_RESOURCES',
1737: p_column_name => 'ATTRIBUTE'||to_char(bom_attr4),
1738: x_message => msgbuf) = TRUE THEN
1739:
1740: FND_MESSAGE.set_name('MSC','MSC_ATTRIBUTE_EXISTS');
1741: FND_MESSAGE.set_token('ATTRIBUTE','ATTRIBUTE'||to_char(bom_attr4));
1742: FND_MESSAGE.set_token('TABLE','BOM_DEPARTMENT_RESOURCES');
1743: msgbuf := FND_MESSAGE.get;
1744: LOG_MESSAGE(msgbuf);

Line 1741: FND_MESSAGE.set_token('ATTRIBUTE','ATTRIBUTE'||to_char(bom_attr4));

1737: p_column_name => 'ATTRIBUTE'||to_char(bom_attr4),
1738: x_message => msgbuf) = TRUE THEN
1739:
1740: FND_MESSAGE.set_name('MSC','MSC_ATTRIBUTE_EXISTS');
1741: FND_MESSAGE.set_token('ATTRIBUTE','ATTRIBUTE'||to_char(bom_attr4));
1742: FND_MESSAGE.set_token('TABLE','BOM_DEPARTMENT_RESOURCES');
1743: msgbuf := FND_MESSAGE.get;
1744: LOG_MESSAGE(msgbuf);
1745: ELSIF

Line 1742: FND_MESSAGE.set_token('TABLE','BOM_DEPARTMENT_RESOURCES');

1738: x_message => msgbuf) = TRUE THEN
1739:
1740: FND_MESSAGE.set_name('MSC','MSC_ATTRIBUTE_EXISTS');
1741: FND_MESSAGE.set_token('ATTRIBUTE','ATTRIBUTE'||to_char(bom_attr4));
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(

Line 1743: msgbuf := FND_MESSAGE.get;

1739:
1740: FND_MESSAGE.set_name('MSC','MSC_ATTRIBUTE_EXISTS');
1741: FND_MESSAGE.set_token('ATTRIBUTE','ATTRIBUTE'||to_char(bom_attr4));
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',

Line 1751: FND_MESSAGE.set_name('MSC','MSC_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
1751: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');
1752: FND_MESSAGE.set_token('SEGMENT','Maximum Batch Capacity');
1753: FND_MESSAGE.set_token('TABLE','BOM_DEPARTMENT_RESOURCES');
1754: msgbuf := FND_MESSAGE.get;
1755: LOG_MESSAGE(msgbuf);

Line 1752: FND_MESSAGE.set_token('SEGMENT','Maximum Batch Capacity');

1748: p_flexfield_name=>'BOM_DEPARTMENT_RESOURCES',
1749: p_context_code=>'Global Data Elements',
1750: p_segment_name=>'Maximum Batch Capacity') = TRUE THEN
1751: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');
1752: FND_MESSAGE.set_token('SEGMENT','Maximum Batch Capacity');
1753: FND_MESSAGE.set_token('TABLE','BOM_DEPARTMENT_RESOURCES');
1754: msgbuf := FND_MESSAGE.get;
1755: LOG_MESSAGE(msgbuf);
1756: ELSE

Line 1753: FND_MESSAGE.set_token('TABLE','BOM_DEPARTMENT_RESOURCES');

1749: p_context_code=>'Global Data Elements',
1750: p_segment_name=>'Maximum Batch Capacity') = TRUE THEN
1751: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');
1752: FND_MESSAGE.set_token('SEGMENT','Maximum Batch Capacity');
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(

Line 1754: msgbuf := FND_MESSAGE.get;

1750: p_segment_name=>'Maximum Batch Capacity') = TRUE THEN
1751: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');
1752: FND_MESSAGE.set_token('SEGMENT','Maximum Batch Capacity');
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',

Line 1799: FND_MESSAGE.set_name('MSC','MSC_ATTRIBUTE_EXISTS');

1795: p_table_name => 'BOM_DEPARTMENT_RESOURCES',
1796: p_column_name => 'ATTRIBUTE'||to_char(bom_attr5),
1797: x_message => msgbuf) = TRUE THEN
1798:
1799: FND_MESSAGE.set_name('MSC','MSC_ATTRIBUTE_EXISTS');
1800: FND_MESSAGE.set_token('ATTRIBUTE','ATTRIBUTE'||to_char(bom_attr5));
1801: FND_MESSAGE.set_token('TABLE','BOM_DEPARTMENT_RESOURCES');
1802: msgbuf := FND_MESSAGE.get;
1803: LOG_MESSAGE(msgbuf);

Line 1800: FND_MESSAGE.set_token('ATTRIBUTE','ATTRIBUTE'||to_char(bom_attr5));

1796: p_column_name => 'ATTRIBUTE'||to_char(bom_attr5),
1797: x_message => msgbuf) = TRUE THEN
1798:
1799: FND_MESSAGE.set_name('MSC','MSC_ATTRIBUTE_EXISTS');
1800: FND_MESSAGE.set_token('ATTRIBUTE','ATTRIBUTE'||to_char(bom_attr5));
1801: FND_MESSAGE.set_token('TABLE','BOM_DEPARTMENT_RESOURCES');
1802: msgbuf := FND_MESSAGE.get;
1803: LOG_MESSAGE(msgbuf);
1804: ELSIF

Line 1801: FND_MESSAGE.set_token('TABLE','BOM_DEPARTMENT_RESOURCES');

1797: x_message => msgbuf) = TRUE THEN
1798:
1799: FND_MESSAGE.set_name('MSC','MSC_ATTRIBUTE_EXISTS');
1800: FND_MESSAGE.set_token('ATTRIBUTE','ATTRIBUTE'||to_char(bom_attr5));
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(

Line 1802: msgbuf := FND_MESSAGE.get;

1798:
1799: FND_MESSAGE.set_name('MSC','MSC_ATTRIBUTE_EXISTS');
1800: FND_MESSAGE.set_token('ATTRIBUTE','ATTRIBUTE'||to_char(bom_attr5));
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',

Line 1810: FND_MESSAGE.set_name('MSC','MSC_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
1810: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');
1811: FND_MESSAGE.set_token('SEGMENT','Batchable Unit of Measure');
1812: FND_MESSAGE.set_token('TABLE','BOM_DEPARTMENT_RESOURCES');
1813: msgbuf := FND_MESSAGE.get;
1814: LOG_MESSAGE(msgbuf);

Line 1811: FND_MESSAGE.set_token('SEGMENT','Batchable Unit of Measure');

1807: p_flexfield_name=>'BOM_DEPARTMENT_RESOURCES',
1808: p_context_code=>'Global Data Elements',
1809: p_segment_name=>'Batchable Unit of Measure') = TRUE THEN
1810: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');
1811: FND_MESSAGE.set_token('SEGMENT','Batchable Unit of Measure');
1812: FND_MESSAGE.set_token('TABLE','BOM_DEPARTMENT_RESOURCES');
1813: msgbuf := FND_MESSAGE.get;
1814: LOG_MESSAGE(msgbuf);
1815: ELSE

Line 1812: FND_MESSAGE.set_token('TABLE','BOM_DEPARTMENT_RESOURCES');

1808: p_context_code=>'Global Data Elements',
1809: p_segment_name=>'Batchable Unit of Measure') = TRUE THEN
1810: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');
1811: FND_MESSAGE.set_token('SEGMENT','Batchable Unit of Measure');
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(

Line 1813: msgbuf := FND_MESSAGE.get;

1809: p_segment_name=>'Batchable Unit of Measure') = TRUE THEN
1810: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');
1811: FND_MESSAGE.set_token('SEGMENT','Batchable Unit of Measure');
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',

Line 1868: substr(fnd_message.get,1,240);

1864:
1865: EXCEPTION
1866: WHEN conc_failure THEN
1867: errbuf := 'Error ' ||
1868: substr(fnd_message.get,1,240);
1869: retcode := 2;
1870:
1871: WHEN OTHERS THEN
1872: rollback;

Line 1908: FND_MESSAGE.set_name('MSC','MSC_ATTRIBUTE_EXISTS');

1904: p_table_name => 'MRP_FORECAST_DATES',
1905: p_column_name => 'ATTRIBUTE'||to_char(fcst_attr1),
1906: x_message => msgbuf) = TRUE THEN
1907:
1908: FND_MESSAGE.set_name('MSC','MSC_ATTRIBUTE_EXISTS');
1909: FND_MESSAGE.set_token('ATTRIBUTE','ATTRIBUTE'||to_char(fcst_attr1));
1910: FND_MESSAGE.set_token('TABLE','MRP_FORECAST_DATES');
1911: msgbuf := FND_MESSAGE.get;
1912: LOG_MESSAGE(msgbuf);

Line 1909: FND_MESSAGE.set_token('ATTRIBUTE','ATTRIBUTE'||to_char(fcst_attr1));

1905: p_column_name => 'ATTRIBUTE'||to_char(fcst_attr1),
1906: x_message => msgbuf) = TRUE THEN
1907:
1908: FND_MESSAGE.set_name('MSC','MSC_ATTRIBUTE_EXISTS');
1909: FND_MESSAGE.set_token('ATTRIBUTE','ATTRIBUTE'||to_char(fcst_attr1));
1910: FND_MESSAGE.set_token('TABLE','MRP_FORECAST_DATES');
1911: msgbuf := FND_MESSAGE.get;
1912: LOG_MESSAGE(msgbuf);
1913:

Line 1910: FND_MESSAGE.set_token('TABLE','MRP_FORECAST_DATES');

1906: x_message => msgbuf) = TRUE THEN
1907:
1908: FND_MESSAGE.set_name('MSC','MSC_ATTRIBUTE_EXISTS');
1909: FND_MESSAGE.set_token('ATTRIBUTE','ATTRIBUTE'||to_char(fcst_attr1));
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(

Line 1911: msgbuf := FND_MESSAGE.get;

1907:
1908: FND_MESSAGE.set_name('MSC','MSC_ATTRIBUTE_EXISTS');
1909: FND_MESSAGE.set_token('ATTRIBUTE','ATTRIBUTE'||to_char(fcst_attr1));
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',

Line 1920: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');

1916: p_flexfield_name=>'MRP_FORECAST_DATES',
1917: p_context_code=>'Global Data Elements',
1918: p_segment_name=>'Forecast Priority') = TRUE THEN
1919:
1920: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');
1921: FND_MESSAGE.set_token('SEGMENT','Forecast Priority');
1922: FND_MESSAGE.set_token('TABLE','MRP_FORECAST_DATES');
1923: msgbuf := FND_MESSAGE.get;
1924: LOG_MESSAGE(msgbuf);

Line 1921: FND_MESSAGE.set_token('SEGMENT','Forecast Priority');

1917: p_context_code=>'Global Data Elements',
1918: p_segment_name=>'Forecast Priority') = TRUE THEN
1919:
1920: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');
1921: FND_MESSAGE.set_token('SEGMENT','Forecast Priority');
1922: FND_MESSAGE.set_token('TABLE','MRP_FORECAST_DATES');
1923: msgbuf := FND_MESSAGE.get;
1924: LOG_MESSAGE(msgbuf);
1925:

Line 1922: FND_MESSAGE.set_token('TABLE','MRP_FORECAST_DATES');

1918: p_segment_name=>'Forecast Priority') = TRUE THEN
1919:
1920: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');
1921: FND_MESSAGE.set_token('SEGMENT','Forecast Priority');
1922: FND_MESSAGE.set_token('TABLE','MRP_FORECAST_DATES');
1923: msgbuf := FND_MESSAGE.get;
1924: LOG_MESSAGE(msgbuf);
1925:
1926: ELSE

Line 1923: msgbuf := FND_MESSAGE.get;

1919:
1920: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');
1921: FND_MESSAGE.set_token('SEGMENT','Forecast Priority');
1922: FND_MESSAGE.set_token('TABLE','MRP_FORECAST_DATES');
1923: msgbuf := FND_MESSAGE.get;
1924: LOG_MESSAGE(msgbuf);
1925:
1926: ELSE
1927: fnd_flex_dsc_api.create_segment(

Line 1978: substr(fnd_message.get,1,240);

1974:
1975: EXCEPTION
1976: WHEN conc_failure THEN
1977: errbuf := 'Error ' ||
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

Line 2019: FND_MESSAGE.set_name('MSC','MSC_ATTRIBUTE_EXISTS');

2015: p_table_name => 'WSH_REGIONS',
2016: p_column_name => 'ATTRIBUTE'||to_char(oper_attr1),
2017: x_message => msgbuf) = TRUE THEN
2018:
2019: FND_MESSAGE.set_name('MSC','MSC_ATTRIBUTE_EXISTS');
2020: FND_MESSAGE.set_token('ATTRIBUTE','ATTRIBUTE'||to_char(oper_attr1));
2021: FND_MESSAGE.set_token('TABLE','WSH_REGIONS');
2022: msgbuf := FND_MESSAGE.get;
2023: LOG_MESSAGE(msgbuf);

Line 2020: FND_MESSAGE.set_token('ATTRIBUTE','ATTRIBUTE'||to_char(oper_attr1));

2016: p_column_name => 'ATTRIBUTE'||to_char(oper_attr1),
2017: x_message => msgbuf) = TRUE THEN
2018:
2019: FND_MESSAGE.set_name('MSC','MSC_ATTRIBUTE_EXISTS');
2020: FND_MESSAGE.set_token('ATTRIBUTE','ATTRIBUTE'||to_char(oper_attr1));
2021: FND_MESSAGE.set_token('TABLE','WSH_REGIONS');
2022: msgbuf := FND_MESSAGE.get;
2023: LOG_MESSAGE(msgbuf);
2024: ELSIF

Line 2021: FND_MESSAGE.set_token('TABLE','WSH_REGIONS');

2017: x_message => msgbuf) = TRUE THEN
2018:
2019: FND_MESSAGE.set_name('MSC','MSC_ATTRIBUTE_EXISTS');
2020: FND_MESSAGE.set_token('ATTRIBUTE','ATTRIBUTE'||to_char(oper_attr1));
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(

Line 2022: msgbuf := FND_MESSAGE.get;

2018:
2019: FND_MESSAGE.set_name('MSC','MSC_ATTRIBUTE_EXISTS');
2020: FND_MESSAGE.set_token('ATTRIBUTE','ATTRIBUTE'||to_char(oper_attr1));
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',

Line 2030: FND_MESSAGE.set_name('MSC','MSC_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
2030: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');
2031: FND_MESSAGE.set_token('SEGMENT','Zone Usage');
2032: FND_MESSAGE.set_token('TABLE','WSH_REGIONS');
2033: msgbuf := FND_MESSAGE.get;
2034: LOG_MESSAGE(msgbuf);

Line 2031: FND_MESSAGE.set_token('SEGMENT','Zone Usage');

2027: p_flexfield_name=>'WSH_REGIONS',
2028: p_context_code=>'ZONES_DFF',
2029: p_segment_name=>'Zone Usage') = TRUE THEN
2030: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');
2031: FND_MESSAGE.set_token('SEGMENT','Zone Usage');
2032: FND_MESSAGE.set_token('TABLE','WSH_REGIONS');
2033: msgbuf := FND_MESSAGE.get;
2034: LOG_MESSAGE(msgbuf);
2035: ELSE

Line 2032: FND_MESSAGE.set_token('TABLE','WSH_REGIONS');

2028: p_context_code=>'ZONES_DFF',
2029: p_segment_name=>'Zone Usage') = TRUE THEN
2030: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');
2031: FND_MESSAGE.set_token('SEGMENT','Zone Usage');
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(

Line 2033: msgbuf := FND_MESSAGE.get;

2029: p_segment_name=>'Zone Usage') = TRUE THEN
2030: FND_MESSAGE.set_name('MSC','MSC_SEGMENT_EXISTS');
2031: FND_MESSAGE.set_token('SEGMENT','Zone Usage');
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',

Line 2080: substr(fnd_message.get,1,240);

2076: EXCEPTION
2077:
2078: WHEN conc_failure THEN
2079: errbuf := 'Error ' ||
2080: substr(fnd_message.get,1,240);
2081: retcode := 2;
2082:
2083: WHEN OTHERS THEN
2084: rollback;