eTRM uses javascript that opens and focuses a separate window to display reports. Your browser does not appear to support javascript. This should not prevent you from using eTRM but it does mean the window focus feature will not work. Please check the contents of other windows on your desktop if you click on a link that does not appear to do anything.

APPS.AHL_MC_RULE_PUB dependencies on FND_MSG_PUB

Line 73: FND_MSG_PUB.Initialize;

69: END IF;
70:
71: -- Initialize message list if p_init_msg_list is set to TRUE
72: IF FND_API.To_Boolean(p_init_msg_list) THEN
73: FND_MSG_PUB.Initialize;
74: END IF;
75:
76: IF (FND_LOG.level_statement >= FND_LOG.g_current_runtime_level) THEN
77: FND_LOG.string(FND_LOG.level_statement,l_full_name,

Line 105: FND_MSG_PUB.ADD;

101: -- check for UI rule stmt table
102: IF (p_rule_stmt_tbl.COUNT < 1) THEN
103: -- input is NULL
104: FND_MESSAGE.Set_Name('AHL','AHL_MC_RULE_STMT_NULL');
105: FND_MSG_PUB.ADD;
106: RAISE FND_API.G_EXC_ERROR;
107: END IF;
108:
109: -- call Convert_Rule_Stmt_Values_to_Id

Line 150: FND_MSG_PUB.Count_And_Get

146: COMMIT WORK;
147: END IF;
148:
149: -- Standard call to get message count and if count is 1, get message info
150: FND_MSG_PUB.Count_And_Get
151: ( p_count => x_msg_count,
152: p_data => x_msg_data,
153: p_encoded => FND_API.G_FALSE
154: );

Line 164: FND_MSG_PUB.Count_And_Get( p_count => x_msg_count,

160: EXCEPTION
161: WHEN FND_API.G_EXC_ERROR THEN
162: Rollback to Insert_Rule_Pub;
163: x_return_status := FND_API.G_RET_STS_ERROR;
164: FND_MSG_PUB.Count_And_Get( p_count => x_msg_count,
165: p_data => x_msg_data,
166: p_encoded => fnd_api.g_false);
167:
168: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN

Line 171: FND_MSG_PUB.Count_And_Get( p_count => x_msg_count,

167:
168: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
169: Rollback to Insert_Rule_Pub;
170: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
171: FND_MSG_PUB.Count_And_Get( p_count => x_msg_count,
172: p_data => x_msg_data,
173: p_encoded => fnd_api.g_false);
174:
175: WHEN OTHERS THEN

Line 178: FND_MSG_PUB.Add_Exc_Msg( p_pkg_name => G_PKG_NAME,

174:
175: WHEN OTHERS THEN
176: Rollback to Insert_Rule_Pub;
177: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
178: FND_MSG_PUB.Add_Exc_Msg( p_pkg_name => G_PKG_NAME,
179: p_procedure_name => l_api_name,
180: p_error_text => SQLERRM);
181: FND_MSG_PUB.Count_And_Get( p_count => x_msg_count,
182: p_data => x_msg_data,

Line 181: FND_MSG_PUB.Count_And_Get( p_count => x_msg_count,

177: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
178: FND_MSG_PUB.Add_Exc_Msg( p_pkg_name => G_PKG_NAME,
179: p_procedure_name => l_api_name,
180: p_error_text => SQLERRM);
181: FND_MSG_PUB.Count_And_Get( p_count => x_msg_count,
182: p_data => x_msg_data,
183: p_encoded => FND_API.G_FALSE);
184:
185: END Insert_Rule;

Line 242: FND_MSG_PUB.Initialize;

238: END IF;
239:
240: -- Initialize message list if p_init_msg_list is set to TRUE
241: IF FND_API.To_Boolean(p_init_msg_list) THEN
242: FND_MSG_PUB.Initialize;
243: END IF;
244:
245: IF (FND_LOG.level_statement >= FND_LOG.g_current_runtime_level) THEN
246: FND_LOG.string(FND_LOG.level_statement,l_full_name,

Line 259: FND_MSG_PUB.ADD;

255:
256: -- check input parameters
257: IF (p_rule_rec.object_version_number IS NULL) THEN
258: FND_MESSAGE.Set_Name('AHL','AHL_MC_RULE_OBJ_VER_NULL');
259: FND_MSG_PUB.ADD;
260: RAISE FND_API.G_EXC_ERROR;
261: END IF;
262:
263: -- call Convert_Rule_Values_to_Id

Line 281: FND_MSG_PUB.ADD;

277: -- check for UI rule stmt table
278: IF (p_rule_stmt_tbl.COUNT < 1) THEN
279: -- input is NULL
280: FND_MESSAGE.Set_Name('AHL','AHL_MC_RULE_STMT_NULL');
281: FND_MSG_PUB.ADD;
282: RAISE FND_API.G_EXC_ERROR;
283: END IF;
284:
285: -- call Convert_Rule_Stmt_Values_to_Id

Line 326: FND_MSG_PUB.Count_And_Get

322: COMMIT WORK;
323: END IF;
324:
325: -- Standard call to get message count and if count is 1, get message info
326: FND_MSG_PUB.Count_And_Get
327: ( p_count => x_msg_count,
328: p_data => x_msg_data,
329: p_encoded => FND_API.G_FALSE
330: );

Line 340: FND_MSG_PUB.Count_And_Get( p_count => x_msg_count,

336: EXCEPTION
337: WHEN FND_API.G_EXC_ERROR THEN
338: Rollback to Update_Rule_Pub;
339: x_return_status := FND_API.G_RET_STS_ERROR;
340: FND_MSG_PUB.Count_And_Get( p_count => x_msg_count,
341: p_data => x_msg_data,
342: p_encoded => fnd_api.g_false);
343:
344: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN

Line 347: FND_MSG_PUB.Count_And_Get( p_count => x_msg_count,

343:
344: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
345: Rollback to Update_Rule_Pub;
346: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
347: FND_MSG_PUB.Count_And_Get( p_count => x_msg_count,
348: p_data => x_msg_data,
349: p_encoded => fnd_api.g_false);
350:
351: WHEN OTHERS THEN

Line 354: FND_MSG_PUB.Add_Exc_Msg( p_pkg_name => G_PKG_NAME,

350:
351: WHEN OTHERS THEN
352: Rollback to Update_Rule_Pub;
353: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
354: FND_MSG_PUB.Add_Exc_Msg( p_pkg_name => G_PKG_NAME,
355: p_procedure_name => l_api_name,
356: p_error_text => SQLERRM);
357: FND_MSG_PUB.Count_And_Get( p_count => x_msg_count,
358: p_data => x_msg_data,

Line 357: FND_MSG_PUB.Count_And_Get( p_count => x_msg_count,

353: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
354: FND_MSG_PUB.Add_Exc_Msg( p_pkg_name => G_PKG_NAME,
355: p_procedure_name => l_api_name,
356: p_error_text => SQLERRM);
357: FND_MSG_PUB.Count_And_Get( p_count => x_msg_count,
358: p_data => x_msg_data,
359: p_encoded => FND_API.G_FALSE);
360:
361: END Update_Rule;

Line 422: FND_MSG_PUB.Initialize;

418: END IF;
419:
420: -- Initialize message list if p_init_msg_list is set to TRUE
421: IF FND_API.To_Boolean(p_init_msg_list) THEN
422: FND_MSG_PUB.Initialize;
423: END IF;
424:
425: IF (FND_LOG.level_statement >= FND_LOG.g_current_runtime_level) THEN
426: FND_LOG.string(FND_LOG.level_statement,l_full_name,

Line 438: FND_MSG_PUB.ADD;

434:
435: -- check input parameters
436: IF (p_rule_rec.object_version_number IS NULL) THEN
437: FND_MESSAGE.Set_Name('AHL','AHL_MC_RULE_OBJ_VER_NULL');
438: FND_MSG_PUB.ADD;
439: RAISE FND_API.G_EXC_ERROR;
440: END IF;
441:
442: -- call Convert_Rule_Values_to_Id

Line 491: FND_MSG_PUB.Count_And_Get

487: COMMIT WORK;
488: END IF;
489:
490: -- Standard call to get message count and if count is 1, get message info
491: FND_MSG_PUB.Count_And_Get
492: ( p_count => x_msg_count,
493: p_data => x_msg_data,
494: p_encoded => FND_API.G_FALSE
495: );

Line 505: FND_MSG_PUB.Count_And_Get( p_count => x_msg_count,

501: EXCEPTION
502: WHEN FND_API.G_EXC_ERROR THEN
503: Rollback to Delete_Rule_Pub;
504: x_return_status := FND_API.G_RET_STS_ERROR;
505: FND_MSG_PUB.Count_And_Get( p_count => x_msg_count,
506: p_data => x_msg_data,
507: p_encoded => fnd_api.g_false);
508:
509: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN

Line 512: FND_MSG_PUB.Count_And_Get( p_count => x_msg_count,

508:
509: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
510: Rollback to Delete_Rule_Pub;
511: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
512: FND_MSG_PUB.Count_And_Get( p_count => x_msg_count,
513: p_data => x_msg_data,
514: p_encoded => fnd_api.g_false);
515:
516: WHEN OTHERS THEN

Line 519: FND_MSG_PUB.Add_Exc_Msg( p_pkg_name => G_PKG_NAME,

515:
516: WHEN OTHERS THEN
517: Rollback to Delete_Rule_Pub;
518: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
519: FND_MSG_PUB.Add_Exc_Msg( p_pkg_name => G_PKG_NAME,
520: p_procedure_name => l_api_name,
521: p_error_text => SQLERRM);
522: FND_MSG_PUB.Count_And_Get( p_count => x_msg_count,
523: p_data => x_msg_data,

Line 522: FND_MSG_PUB.Count_And_Get( p_count => x_msg_count,

518: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
519: FND_MSG_PUB.Add_Exc_Msg( p_pkg_name => G_PKG_NAME,
520: p_procedure_name => l_api_name,
521: p_error_text => SQLERRM);
522: FND_MSG_PUB.Count_And_Get( p_count => x_msg_count,
523: p_data => x_msg_data,
524: p_encoded => FND_API.G_FALSE);
525:
526: END Delete_Rule;

Line 604: FND_MSG_PUB.Initialize;

600: END IF;
601:
602: -- Initialize message list if p_init_msg_list is set to TRUE
603: IF FND_API.To_Boolean(p_init_msg_list) THEN
604: FND_MSG_PUB.Initialize;
605: END IF;
606:
607: IF (FND_LOG.level_statement >= FND_LOG.g_current_runtime_level) THEN
608: FND_LOG.string(FND_LOG.level_statement,l_full_name,

Line 624: FND_MSG_PUB.ADD;

620: -- check with mc_name and revision
621: IF (p_from_mc_name IS NULL) OR (p_from_revision IS NULL) THEN
622: -- input is NULL
623: FND_MESSAGE.Set_Name('AHL','AHL_MC_RULE_MC_NULL');
624: FND_MSG_PUB.ADD;
625: RAISE FND_API.G_EXC_ERROR;
626: ELSE
627: OPEN chk_mc_name_csr(p_from_mc_name, p_from_revision);
628: FETCH chk_mc_name_csr INTO l_from_mc_header_id;

Line 636: FND_MSG_PUB.ADD;

632: -- input is invalid
633: FND_MESSAGE.Set_Name('AHL','AHL_MC_RULE_MC_NAME_INV');
634: FND_MESSAGE.Set_Token('MC_NAME',p_from_mc_name);
635: FND_MESSAGE.Set_Token('MC_REV',p_from_revision);
636: FND_MSG_PUB.ADD;
637: RAISE FND_API.G_EXC_ERROR;
638: END IF;
639:
640: CLOSE chk_mc_name_csr;

Line 652: FND_MSG_PUB.ADD;

648: CLOSE chk_mc_header_id_csr;
649: -- input is invalid
650: FND_MESSAGE.Set_Name('AHL','AHL_MC_RULE_MC_HDR_ID_INV');
651: FND_MESSAGE.Set_Token('MC_ID',p_from_mc_header_id);
652: FND_MSG_PUB.ADD;
653: RAISE FND_API.G_EXC_ERROR;
654: END IF;
655:
656: l_from_mc_header_id := p_from_mc_header_id;

Line 666: FND_MSG_PUB.ADD;

662: -- check with mc_name and revision
663: IF (p_to_mc_name IS NULL) OR (p_to_revision IS NULL) THEN
664: -- input is NULL
665: FND_MESSAGE.Set_Name('AHL','AHL_MC_RULE_MC_NULL');
666: FND_MSG_PUB.ADD;
667: RAISE FND_API.G_EXC_ERROR;
668: ELSE
669: OPEN chk_mc_name_csr(p_to_mc_name, p_to_revision);
670: FETCH chk_mc_name_csr INTO l_to_mc_header_id;

Line 678: FND_MSG_PUB.ADD;

674: -- input is invalid
675: FND_MESSAGE.Set_Name('AHL','AHL_MC_RULE_MC_NAME_INV');
676: FND_MESSAGE.Set_Token('MC_NAME',p_to_mc_name);
677: FND_MESSAGE.Set_Token('MC_REV',p_to_revision);
678: FND_MSG_PUB.ADD;
679: RAISE FND_API.G_EXC_ERROR;
680: END IF;
681:
682: CLOSE chk_mc_name_csr;

Line 694: FND_MSG_PUB.ADD;

690: CLOSE chk_mc_header_id_csr;
691: -- input is invalid
692: FND_MESSAGE.Set_Name('AHL','AHL_MC_RULE_MC_HDR_ID_INV');
693: FND_MESSAGE.Set_Token('MC_ID',p_to_mc_header_id);
694: FND_MSG_PUB.ADD;
695: RAISE FND_API.G_EXC_ERROR;
696: END IF;
697:
698: l_to_mc_header_id := p_to_mc_header_id;

Line 749: FND_MSG_PUB.Count_And_Get

745: COMMIT WORK;
746: END IF;
747:
748: -- Standard call to get message count and if count is 1, get message info
749: FND_MSG_PUB.Count_And_Get
750: ( p_count => x_msg_count,
751: p_data => x_msg_data,
752: p_encoded => FND_API.G_FALSE
753: );

Line 763: FND_MSG_PUB.Count_And_Get( p_count => x_msg_count,

759: EXCEPTION
760: WHEN FND_API.G_EXC_ERROR THEN
761: Rollback to Copy_Rules_For_MC_Pub;
762: x_return_status := FND_API.G_RET_STS_ERROR;
763: FND_MSG_PUB.Count_And_Get( p_count => x_msg_count,
764: p_data => x_msg_data,
765: p_encoded => fnd_api.g_false);
766:
767: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN

Line 770: FND_MSG_PUB.Count_And_Get( p_count => x_msg_count,

766:
767: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
768: Rollback to Copy_Rules_For_MC_Pub;
769: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
770: FND_MSG_PUB.Count_And_Get( p_count => x_msg_count,
771: p_data => x_msg_data,
772: p_encoded => fnd_api.g_false);
773:
774: WHEN OTHERS THEN

Line 777: FND_MSG_PUB.Add_Exc_Msg( p_pkg_name => G_PKG_NAME,

773:
774: WHEN OTHERS THEN
775: Rollback to Copy_Rules_For_MC_Pub;
776: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
777: FND_MSG_PUB.Add_Exc_Msg( p_pkg_name => G_PKG_NAME,
778: p_procedure_name => l_api_name,
779: p_error_text => SQLERRM);
780: FND_MSG_PUB.Count_And_Get( p_count => x_msg_count,
781: p_data => x_msg_data,

Line 780: FND_MSG_PUB.Count_And_Get( p_count => x_msg_count,

776: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
777: FND_MSG_PUB.Add_Exc_Msg( p_pkg_name => G_PKG_NAME,
778: p_procedure_name => l_api_name,
779: p_error_text => SQLERRM);
780: FND_MSG_PUB.Count_And_Get( p_count => x_msg_count,
781: p_data => x_msg_data,
782: p_encoded => FND_API.G_FALSE);
783:
784: END Copy_Rules_For_MC;

Line 853: FND_MSG_PUB.Initialize;

849: END IF;
850:
851: -- Initialize message list if p_init_msg_list is set to TRUE
852: IF FND_API.To_Boolean(p_init_msg_list) THEN
853: FND_MSG_PUB.Initialize;
854: END IF;
855:
856: IF (FND_LOG.level_statement >= FND_LOG.g_current_runtime_level) THEN
857: FND_LOG.string(FND_LOG.level_statement,l_full_name,

Line 869: FND_MSG_PUB.ADD;

865: -- check with mc_name and revision
866: IF (p_mc_name IS NULL) OR (p_revision IS NULL) THEN
867: -- input is NULL
868: FND_MESSAGE.Set_Name('AHL','AHL_MC_RULE_MC_NULL');
869: FND_MSG_PUB.ADD;
870: RAISE FND_API.G_EXC_ERROR;
871: ELSE
872: OPEN chk_mc_name_csr(p_mc_name, p_revision);
873: FETCH chk_mc_name_csr INTO l_mc_header_id;

Line 881: FND_MSG_PUB.ADD;

877: -- input is invalid
878: FND_MESSAGE.Set_Name('AHL','AHL_MC_RULE_MC_NAME_INV');
879: FND_MESSAGE.Set_Token('MC_NAME',p_mc_name);
880: FND_MESSAGE.Set_Token('MC_REV',p_revision);
881: FND_MSG_PUB.ADD;
882: RAISE FND_API.G_EXC_ERROR;
883: END IF;
884:
885: CLOSE chk_mc_name_csr;

Line 897: FND_MSG_PUB.ADD;

893: CLOSE chk_mc_header_id_csr;
894: -- input is invalid
895: FND_MESSAGE.Set_Name('AHL','AHL_MC_RULE_MC_HDR_ID_INV');
896: FND_MESSAGE.Set_Token('MC_ID',p_mc_header_id);
897: FND_MSG_PUB.ADD;
898: RAISE FND_API.G_EXC_ERROR;
899: END IF;
900:
901: l_mc_header_id := p_mc_header_id;

Line 948: FND_MSG_PUB.Count_And_Get

944: COMMIT WORK;
945: END IF;
946:
947: -- Standard call to get message count and if count is 1, get message info
948: FND_MSG_PUB.Count_And_Get
949: ( p_count => x_msg_count,
950: p_data => x_msg_data,
951: p_encoded => FND_API.G_FALSE
952: );

Line 962: FND_MSG_PUB.Count_And_Get( p_count => x_msg_count,

958: EXCEPTION
959: WHEN FND_API.G_EXC_ERROR THEN
960: Rollback to Delete_Rules_For_MC_Pub;
961: x_return_status := FND_API.G_RET_STS_ERROR;
962: FND_MSG_PUB.Count_And_Get( p_count => x_msg_count,
963: p_data => x_msg_data,
964: p_encoded => fnd_api.g_false);
965:
966: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN

Line 969: FND_MSG_PUB.Count_And_Get( p_count => x_msg_count,

965:
966: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
967: Rollback to Delete_Rules_For_MC_Pub;
968: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
969: FND_MSG_PUB.Count_And_Get( p_count => x_msg_count,
970: p_data => x_msg_data,
971: p_encoded => fnd_api.g_false);
972:
973: WHEN OTHERS THEN

Line 976: FND_MSG_PUB.Add_Exc_Msg( p_pkg_name => G_PKG_NAME,

972:
973: WHEN OTHERS THEN
974: Rollback to Delete_Rules_For_MC_Pub;
975: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
976: FND_MSG_PUB.Add_Exc_Msg( p_pkg_name => G_PKG_NAME,
977: p_procedure_name => l_api_name,
978: p_error_text => SQLERRM);
979: FND_MSG_PUB.Count_And_Get( p_count => x_msg_count,
980: p_data => x_msg_data,

Line 979: FND_MSG_PUB.Count_And_Get( p_count => x_msg_count,

975: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
976: FND_MSG_PUB.Add_Exc_Msg( p_pkg_name => G_PKG_NAME,
977: p_procedure_name => l_api_name,
978: p_error_text => SQLERRM);
979: FND_MSG_PUB.Count_And_Get( p_count => x_msg_count,
980: p_data => x_msg_data,
981: p_encoded => FND_API.G_FALSE);
982:
983: END Delete_Rules_For_MC;

Line 1058: FND_MSG_PUB.Initialize;

1054: END IF;
1055:
1056: -- Initialize message list if p_init_msg_list is set to TRUE
1057: IF FND_API.To_Boolean(p_init_msg_list) THEN
1058: FND_MSG_PUB.Initialize;
1059: END IF;
1060:
1061: IF (FND_LOG.level_statement >= FND_LOG.g_current_runtime_level) THEN
1062: FND_LOG.string(FND_LOG.level_statement,l_full_name,

Line 1073: FND_MSG_PUB.ADD;

1069: -- check input parameters
1070: IF (p_encoded_path IS NULL) THEN
1071: -- encoded path cant be NULL
1072: FND_MESSAGE.Set_Name('AHL','AHL_MC_RULE_PATH_NULL');
1073: FND_MSG_PUB.ADD;
1074: RAISE FND_API.G_EXC_ERROR;
1075: ELSIF (p_mc_header_id IS NULL) THEN
1076: -- check with mc_name and revision
1077: IF (p_mc_name IS NULL) OR (p_revision IS NULL) THEN

Line 1080: FND_MSG_PUB.ADD;

1076: -- check with mc_name and revision
1077: IF (p_mc_name IS NULL) OR (p_revision IS NULL) THEN
1078: -- input is NULL
1079: FND_MESSAGE.Set_Name('AHL','AHL_MC_RULE_MC_NULL');
1080: FND_MSG_PUB.ADD;
1081: RAISE FND_API.G_EXC_ERROR;
1082: ELSE
1083: OPEN chk_mc_name_csr(p_mc_name, p_revision);
1084: FETCH chk_mc_name_csr INTO l_mc_header_id;

Line 1092: FND_MSG_PUB.ADD;

1088: -- input is invalid
1089: FND_MESSAGE.Set_Name('AHL','AHL_MC_RULE_MC_NAME_INV');
1090: FND_MESSAGE.Set_Token('MC_NAME',p_mc_name);
1091: FND_MESSAGE.Set_Token('MC_REV',p_revision);
1092: FND_MSG_PUB.ADD;
1093: RAISE FND_API.G_EXC_ERROR;
1094: END IF;
1095:
1096: CLOSE chk_mc_name_csr;

Line 1108: FND_MSG_PUB.ADD;

1104: CLOSE chk_mc_header_id_csr;
1105: -- input is invalid
1106: FND_MESSAGE.Set_Name('AHL','AHL_MC_RULE_MC_HDR_ID_INV');
1107: FND_MESSAGE.Set_Token('MC_ID',p_mc_header_id);
1108: FND_MSG_PUB.ADD;
1109: RAISE FND_API.G_EXC_ERROR;
1110: END IF;
1111:
1112: l_mc_header_id := p_mc_header_id;

Line 1167: FND_MSG_PUB.Count_And_Get

1163: COMMIT WORK;
1164: END IF;
1165:
1166: -- Standard call to get message count and if count is 1, get message info
1167: FND_MSG_PUB.Count_And_Get
1168: ( p_count => x_msg_count,
1169: p_data => x_msg_data,
1170: p_encoded => FND_API.G_FALSE
1171: );

Line 1181: FND_MSG_PUB.Count_And_Get( p_count => x_msg_count,

1177: EXCEPTION
1178: WHEN FND_API.G_EXC_ERROR THEN
1179: Rollback to Get_Rules_For_Position_Pub;
1180: x_return_status := FND_API.G_RET_STS_ERROR;
1181: FND_MSG_PUB.Count_And_Get( p_count => x_msg_count,
1182: p_data => x_msg_data,
1183: p_encoded => fnd_api.g_false);
1184:
1185: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN

Line 1188: FND_MSG_PUB.Count_And_Get( p_count => x_msg_count,

1184:
1185: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
1186: Rollback to Get_Rules_For_Position_Pub;
1187: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
1188: FND_MSG_PUB.Count_And_Get( p_count => x_msg_count,
1189: p_data => x_msg_data,
1190: p_encoded => fnd_api.g_false);
1191:
1192: WHEN OTHERS THEN

Line 1195: FND_MSG_PUB.Add_Exc_Msg( p_pkg_name => G_PKG_NAME,

1191:
1192: WHEN OTHERS THEN
1193: Rollback to Get_Rules_For_Position_Pub;
1194: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
1195: FND_MSG_PUB.Add_Exc_Msg( p_pkg_name => G_PKG_NAME,
1196: p_procedure_name => l_api_name,
1197: p_error_text => SQLERRM);
1198: FND_MSG_PUB.Count_And_Get( p_count => x_msg_count,
1199: p_data => x_msg_data,

Line 1198: FND_MSG_PUB.Count_And_Get( p_count => x_msg_count,

1194: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
1195: FND_MSG_PUB.Add_Exc_Msg( p_pkg_name => G_PKG_NAME,
1196: p_procedure_name => l_api_name,
1197: p_error_text => SQLERRM);
1198: FND_MSG_PUB.Count_And_Get( p_count => x_msg_count,
1199: p_data => x_msg_data,
1200: p_encoded => FND_API.G_FALSE);
1201:
1202: END Get_Rules_For_Position;

Line 1279: FND_MSG_PUB.ADD;

1275: -- check with mc_name and revision
1276: IF (l_rule_rec.mc_name IS NULL) OR (l_rule_rec.mc_revision IS NULL) THEN
1277: -- input is NULL
1278: FND_MESSAGE.Set_Name('AHL','AHL_MC_RULE_MC_NULL');
1279: FND_MSG_PUB.ADD;
1280: RAISE FND_API.G_EXC_ERROR;
1281: ELSE
1282: OPEN chk_mc_name_csr(l_rule_rec.mc_name, l_rule_rec.mc_revision);
1283: FETCH chk_mc_name_csr INTO l_mc_header_id;

Line 1291: FND_MSG_PUB.ADD;

1287: -- input is invalid
1288: FND_MESSAGE.Set_Name('AHL','AHL_MC_RULE_MC_NAME_INV');
1289: FND_MESSAGE.Set_Token('MC_NAME',l_rule_rec.mc_name);
1290: FND_MESSAGE.Set_Token('MC_REV',l_rule_rec.mc_revision);
1291: FND_MSG_PUB.ADD;
1292: RAISE FND_API.G_EXC_ERROR;
1293: END IF;
1294:
1295: -- set the mc_header_id

Line 1309: FND_MSG_PUB.ADD;

1305: CLOSE chk_mc_header_id_csr;
1306: -- input is invalid
1307: FND_MESSAGE.Set_Name('AHL','AHL_MC_RULE_MC_HDR_ID_INV');
1308: FND_MESSAGE.Set_Token('MC_ID',l_rule_rec.mc_header_id);
1309: FND_MSG_PUB.ADD;
1310: RAISE FND_API.G_EXC_ERROR;
1311: END IF;
1312:
1313: CLOSE chk_mc_header_id_csr;

Line 1322: FND_MSG_PUB.ADD;

1318: -- check for rule_type_meaning
1319: IF (l_rule_rec.rule_type_meaning IS NULL) THEN
1320: -- input is NULL
1321: FND_MESSAGE.Set_Name('AHL','AHL_MC_RULE_TYPE_NULL');
1322: FND_MSG_PUB.ADD;
1323: RAISE FND_API.G_EXC_ERROR;
1324: ELSE
1325: -- convert the meaning into code
1326: AHL_UTIL_MC_PKG.Convert_To_LookupCode(

Line 1340: FND_MSG_PUB.ADD;

1336: ELSE
1337: -- input is invalid
1338: FND_MESSAGE.Set_Name('AHL','AHL_MC_RULE_STMT_TYPE_INV');
1339: FND_MESSAGE.Set_Token('RULE_TYPE',l_rule_rec.rule_type_meaning);
1340: FND_MSG_PUB.ADD;
1341: RAISE FND_API.G_EXC_ERROR;
1342: END IF;
1343: END IF;
1344: ELSE

Line 1354: FND_MSG_PUB.ADD;

1350: CLOSE chk_lookup_code_csr;
1351: -- input is invalid
1352: FND_MESSAGE.Set_Name('AHL','AHL_MC_RULE_STMT_TYPE_INV');
1353: FND_MESSAGE.Set_Token('RULE_TYPE',l_rule_rec.rule_type_code);
1354: FND_MSG_PUB.ADD;
1355: RAISE FND_API.G_EXC_ERROR;
1356: END IF;
1357:
1358: CLOSE chk_lookup_code_csr;

Line 1379: FND_MSG_PUB.ADD;

1375: -- input is invalid
1376: FND_MESSAGE.Set_Name('AHL','AHL_MC_RULE_RL_NAME_INV');
1377: FND_MESSAGE.Set_Token('RULE_NAME',l_rule_rec.rule_name);
1378: FND_MESSAGE.Set_Token('MC_ID',l_rule_rec.mc_header_id);
1379: FND_MSG_PUB.ADD;
1380: RAISE FND_API.G_EXC_ERROR;
1381: END IF;
1382:
1383: -- set the rule_id

Line 1391: FND_MSG_PUB.ADD;

1387: -- check with mc_name and revision
1388: IF (l_rule_rec.mc_name IS NULL) OR (l_rule_rec.mc_revision IS NULL) THEN
1389: -- input is NULL
1390: FND_MESSAGE.Set_Name('AHL','AHL_MC_RULE_MC_NULL');
1391: FND_MSG_PUB.ADD;
1392: RAISE FND_API.G_EXC_ERROR;
1393: ELSE
1394: OPEN chk_mc_name_csr(l_rule_rec.mc_name, l_rule_rec.mc_revision);
1395: FETCH chk_mc_name_csr INTO l_mc_header_id;

Line 1403: FND_MSG_PUB.ADD;

1399: -- input is invalid
1400: FND_MESSAGE.Set_Name('AHL','AHL_MC_RULE_MC_NAME_INV');
1401: FND_MESSAGE.Set_Token('MC_NAME',l_rule_rec.mc_name);
1402: FND_MESSAGE.Set_Token('MC_REV',l_rule_rec.mc_revision);
1403: FND_MSG_PUB.ADD;
1404: RAISE FND_API.G_EXC_ERROR;
1405: END IF;
1406:
1407: -- set the mc_header_id

Line 1421: FND_MSG_PUB.ADD;

1417: -- input is invalid
1418: FND_MESSAGE.Set_Name('AHL','AHL_MC_RULE_RL_NAME_INV');
1419: FND_MESSAGE.Set_Token('RULE_NAME',l_rule_rec.rule_name);
1420: FND_MESSAGE.Set_Token('MC_ID',l_rule_rec.mc_header_id);
1421: FND_MSG_PUB.ADD;
1422: RAISE FND_API.G_EXC_ERROR;
1423: END IF;
1424:
1425: -- set the rule_id

Line 1433: FND_MSG_PUB.ADD;

1429: END IF;
1430: ELSE
1431: -- input is NULL
1432: FND_MESSAGE.Set_Name('AHL','AHL_MC_RULE_RL_NULL');
1433: FND_MSG_PUB.ADD;
1434: RAISE FND_API.G_EXC_ERROR;
1435: END IF;
1436: ELSE
1437: -- check with rule_id

Line 1446: FND_MSG_PUB.ADD;

1442: CLOSE chk_rule_id_csr;
1443: -- input is invalid
1444: FND_MESSAGE.Set_Name('AHL','AHL_MC_RULE_RL_ID_INV');
1445: FND_MESSAGE.Set_Token('RULE_ID',l_rule_rec.rule_id);
1446: FND_MSG_PUB.ADD;
1447: RAISE FND_API.G_EXC_ERROR;
1448: END IF;
1449:
1450: CLOSE chk_rule_id_csr;

Line 1562: FND_MSG_PUB.ADD;

1558: IF (p_operation_flag = 'U')THEN
1559: IF (l_ui_rule_stmt_tbl(i).rule_statement_id IS NULL) THEN
1560: -- input is NULL
1561: FND_MESSAGE.Set_Name('AHL','AHL_MC_RULE_STMT_ID_NULL');
1562: FND_MSG_PUB.ADD;
1563: l_flag := 'Y';
1564: ELSE
1565: -- check with the rule stmt id
1566: OPEN chk_rule_stmt_id_csr(l_ui_rule_stmt_tbl(i).rule_statement_id);

Line 1573: FND_MSG_PUB.ADD;

1569: IF (chk_rule_stmt_id_csr%NOTFOUND) THEN
1570: -- input is invalid
1571: FND_MESSAGE.Set_Name('AHL','AHL_MC_RULE_STMT_ID_INV');
1572: FND_MESSAGE.Set_Token('RULE_STMT_ID',l_ui_rule_stmt_tbl(i).rule_statement_id);
1573: FND_MSG_PUB.ADD;
1574: l_flag := 'Y';
1575: END IF;
1576:
1577: CLOSE chk_rule_stmt_id_csr;

Line 1582: FND_MSG_PUB.ADD;

1578: END IF;
1579:
1580: IF (l_ui_rule_stmt_tbl(i).rule_stmt_obj_ver_num IS NULL) THEN
1581: FND_MESSAGE.Set_Name('AHL','AHL_MC_RULE_OBJ_VER_NULL');
1582: FND_MSG_PUB.ADD;
1583: l_flag := 'Y';
1584: END IF;
1585: END IF;
1586:

Line 1593: FND_MSG_PUB.ADD;

1589: -- check for operator_meaning
1590: IF (l_ui_rule_stmt_tbl(i).operator_meaning IS NULL) THEN
1591: -- input is NULL
1592: FND_MESSAGE.Set_Name('AHL','AHL_MC_RULE_STMT_OPER_NULL');
1593: FND_MSG_PUB.ADD;
1594: l_flag := 'Y';
1595: ELSE
1596: -- convert the meaning into code
1597: AHL_UTIL_MC_PKG.Convert_To_LookupCode(

Line 1611: FND_MSG_PUB.ADD;

1607: ELSE
1608: -- input is invalid
1609: FND_MESSAGE.Set_Name('AHL','AHL_MC_RULE_OPR_INV');
1610: FND_MESSAGE.Set_Token('OPR',l_ui_rule_stmt_tbl(i).operator_meaning);
1611: FND_MSG_PUB.ADD;
1612: l_flag := 'Y';
1613: END IF;
1614: END IF;
1615: ELSE

Line 1624: FND_MSG_PUB.ADD;

1620: IF (chk_lookup_code_csr%NOTFOUND) THEN
1621: -- input is invalid
1622: FND_MESSAGE.Set_Name('AHL','AHL_MC_RULE_OPR_INV');
1623: FND_MESSAGE.Set_Token('OPR',l_ui_rule_stmt_tbl(i).operator);
1624: FND_MSG_PUB.ADD;
1625: l_flag := 'Y';
1626: END IF;
1627:
1628: CLOSE chk_lookup_code_csr;

Line 1650: FND_MSG_PUB.ADD;

1646: ELSE
1647: -- input is invalid
1648: FND_MESSAGE.Set_Name('AHL','AHL_MC_RULE_RL_OPR_INV');
1649: FND_MESSAGE.Set_Token('RL_OPR',l_ui_rule_stmt_tbl(i).rule_operator_meaning);
1650: FND_MSG_PUB.ADD;
1651: l_flag := 'Y';
1652: END IF;
1653: END IF;
1654: ELSE

Line 1663: FND_MSG_PUB.ADD;

1659: IF (chk_lookup_code_csr%NOTFOUND) THEN
1660: -- input is invalid
1661: FND_MESSAGE.Set_Name('AHL','AHL_MC_RULE_RL_OPR_INV');
1662: FND_MESSAGE.Set_Token('RL_OPR',l_ui_rule_stmt_tbl(i).rule_operator);
1663: FND_MSG_PUB.ADD;
1664: l_flag := 'Y';
1665: END IF;
1666:
1667: CLOSE chk_lookup_code_csr;

Line 1689: FND_MSG_PUB.ADD;

1685: ELSE
1686: -- input is invalid
1687: FND_MESSAGE.Set_Name('AHL','AHL_MC_RULE_OBJ_TYPE_INV');
1688: FND_MESSAGE.Set_Token('OBJ_TYPE',l_ui_rule_stmt_tbl(i).object_type_meaning);
1689: FND_MSG_PUB.ADD;
1690: l_flag := 'Y';
1691: END IF;
1692: END IF;
1693: ELSE

Line 1702: FND_MSG_PUB.ADD;

1698: IF (chk_lookup_code_csr%NOTFOUND) THEN
1699: -- input is invalid
1700: FND_MESSAGE.Set_Name('AHL','AHL_MC_RULE_OBJ_TYPE_INV');
1701: FND_MESSAGE.Set_Token('OBJ_TYPE',l_ui_rule_stmt_tbl(i).object_type);
1702: FND_MSG_PUB.ADD;
1703: l_flag := 'Y';
1704: END IF;
1705:
1706: CLOSE chk_lookup_code_csr;

Line 1717: FND_MSG_PUB.ADD;

1713: -- check for object_meaning
1714: IF (l_ui_rule_stmt_tbl(i).object_meaning IS NULL) THEN
1715: -- input is NULL
1716: FND_MESSAGE.Set_Name('AHL','AHL_MC_RULE_ITM_NULL');
1717: FND_MSG_PUB.ADD;
1718: l_flag := 'Y';
1719: ELSE
1720: OPEN chk_item_name_csr(l_ui_rule_stmt_tbl(i).object_meaning);
1721: FETCH chk_item_name_csr INTO l_item_id;

Line 1727: FND_MSG_PUB.ADD;

1723: IF (chk_item_name_csr%NOTFOUND) THEN
1724: -- input is invalid
1725: FND_MESSAGE.Set_Name('AHL','AHL_MC_RULE_ITM_NAME_INV');
1726: FND_MESSAGE.Set_Token('ITM_NAME',l_ui_rule_stmt_tbl(i).object_meaning);
1727: FND_MSG_PUB.ADD;
1728: l_flag := 'Y';
1729: END IF;
1730:
1731: -- set the object_id

Line 1744: FND_MSG_PUB.ADD;

1740: IF (chk_item_id_csr%NOTFOUND) THEN
1741: -- input is invalid
1742: FND_MESSAGE.Set_Name('AHL','AHL_MC_RULE_ITM_ID_INV');
1743: FND_MESSAGE.Set_Token('ITM_ID',l_ui_rule_stmt_tbl(i).object_id);
1744: FND_MSG_PUB.ADD;
1745: l_flag := 'Y';
1746: END IF;
1747:
1748: CLOSE chk_item_id_csr;

Line 1760: FND_MSG_PUB.ADD;

1756: -- check for object_meaning
1757: IF (l_ui_rule_stmt_tbl(i).object_meaning IS NULL) THEN
1758: -- input is NULL
1759: FND_MESSAGE.Set_Name('AHL','AHL_MC_RULE_MC_ID_NULL');
1760: FND_MSG_PUB.ADD;
1761: l_flag := 'Y';
1762: ELSE
1763: OPEN chk_mc_name_csr(l_ui_rule_stmt_tbl(i).object_meaning);
1764: FETCH chk_mc_name_csr INTO l_mc_id;

Line 1770: FND_MSG_PUB.ADD;

1766: IF (chk_mc_name_csr%NOTFOUND) THEN
1767: -- input is invalid
1768: FND_MESSAGE.Set_Name('AHL','AHL_MC_RULE_MC_ID_NAME_INV');
1769: FND_MESSAGE.Set_Token('MC_NAME',l_ui_rule_stmt_tbl(i).object_meaning);
1770: FND_MSG_PUB.ADD;
1771: l_flag := 'Y';
1772: END IF;
1773:
1774: -- set the object_id

Line 1787: FND_MSG_PUB.ADD;

1783: IF (chk_mc_id_csr%NOTFOUND) THEN
1784: -- input is invalid
1785: FND_MESSAGE.Set_Name('AHL','AHL_MC_RULE_MC_ID_INV');
1786: FND_MESSAGE.Set_Token('MC_ID',l_ui_rule_stmt_tbl(i).object_id);
1787: FND_MSG_PUB.ADD;
1788: l_flag := 'Y';
1789: END IF;
1790:
1791: CLOSE chk_mc_id_csr;