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_API

Line 35: p_init_msg_list IN VARCHAR2 := FND_API.G_FALSE,

31: -- End of Comments
32:
33: PROCEDURE Insert_Rule (
34: p_api_version IN NUMBER,
35: p_init_msg_list IN VARCHAR2 := FND_API.G_FALSE,
36: p_commit IN VARCHAR2 := FND_API.G_FALSE,
37: p_validation_level IN NUMBER := FND_API.G_VALID_LEVEL_FULL,
38: p_module IN VARCHAR2 := 'JSP',
39: p_rule_stmt_tbl IN AHL_MC_RULE_PVT.UI_Rule_Stmt_Tbl_Type,

Line 36: p_commit IN VARCHAR2 := FND_API.G_FALSE,

32:
33: PROCEDURE Insert_Rule (
34: p_api_version IN NUMBER,
35: p_init_msg_list IN VARCHAR2 := FND_API.G_FALSE,
36: p_commit IN VARCHAR2 := FND_API.G_FALSE,
37: p_validation_level IN NUMBER := FND_API.G_VALID_LEVEL_FULL,
38: p_module IN VARCHAR2 := 'JSP',
39: p_rule_stmt_tbl IN AHL_MC_RULE_PVT.UI_Rule_Stmt_Tbl_Type,
40: p_x_rule_rec IN OUT NOCOPY AHL_MC_RULE_PVT.Rule_Rec_Type,

Line 37: p_validation_level IN NUMBER := FND_API.G_VALID_LEVEL_FULL,

33: PROCEDURE Insert_Rule (
34: p_api_version IN NUMBER,
35: p_init_msg_list IN VARCHAR2 := FND_API.G_FALSE,
36: p_commit IN VARCHAR2 := FND_API.G_FALSE,
37: p_validation_level IN NUMBER := FND_API.G_VALID_LEVEL_FULL,
38: p_module IN VARCHAR2 := 'JSP',
39: p_rule_stmt_tbl IN AHL_MC_RULE_PVT.UI_Rule_Stmt_Tbl_Type,
40: p_x_rule_rec IN OUT NOCOPY AHL_MC_RULE_PVT.Rule_Rec_Type,
41: x_return_status OUT NOCOPY VARCHAR2,

Line 63: x_return_status := FND_API.G_RET_STS_SUCCESS;

59: -- Standard start of API savepoint
60: SAVEPOINT Insert_Rule_Pub;
61:
62: -- Initialize Procedure return status to success
63: x_return_status := FND_API.G_RET_STS_SUCCESS;
64:
65: -- Standard call to check for call compatibility
66: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version,
67: l_api_name, G_PKG_NAME) THEN

Line 66: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version,

62: -- Initialize Procedure return status to success
63: x_return_status := FND_API.G_RET_STS_SUCCESS;
64:
65: -- Standard call to check for call compatibility
66: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version,
67: l_api_name, G_PKG_NAME) THEN
68: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
69: END IF;
70:

Line 68: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;

64:
65: -- Standard call to check for call compatibility
66: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version,
67: l_api_name, G_PKG_NAME) THEN
68: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
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

Line 72: IF FND_API.To_Boolean(p_init_msg_list) THEN

68: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
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

Line 106: RAISE FND_API.G_EXC_ERROR;

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
110: Convert_Rule_Stmt_Values_to_Id(l_rule_stmt_tbl, 'I');

Line 131: IF (x_return_status <> FND_API.G_RET_STS_SUCCESS) THEN

127: x_msg_data => x_msg_data
128: );
129:
130: -- check for the return status
131: IF (x_return_status <> FND_API.G_RET_STS_SUCCESS) THEN
132: IF (FND_LOG.level_statement >= FND_LOG.g_current_runtime_level) THEN
133: FND_LOG.string(FND_LOG.level_statement,l_full_name,
134: 'Raising exception with x_return_status => '||x_return_status);
135: END IF;

Line 137: RAISE FND_API.G_EXC_ERROR;

133: FND_LOG.string(FND_LOG.level_statement,l_full_name,
134: 'Raising exception with x_return_status => '||x_return_status);
135: END IF;
136:
137: RAISE FND_API.G_EXC_ERROR;
138: END IF;
139:
140: IF (FND_LOG.level_statement >= FND_LOG.g_current_runtime_level) THEN
141: FND_LOG.string(FND_LOG.level_statement,l_full_name,'After call to private API.');

Line 145: IF FND_API.TO_BOOLEAN(p_commit) THEN

141: FND_LOG.string(FND_LOG.level_statement,l_full_name,'After call to private API.');
142: END IF;
143:
144: -- Standard check of p_commit
145: IF FND_API.TO_BOOLEAN(p_commit) THEN
146: COMMIT WORK;
147: END IF;
148:
149: -- Standard call to get message count and if count is 1, get message info

Line 153: p_encoded => FND_API.G_FALSE

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: );
155:
156: IF (FND_LOG.level_procedure >= FND_LOG.g_current_runtime_level) THEN
157: FND_LOG.string(FND_LOG.level_procedure,l_full_name,'End of the API');

Line 161: WHEN FND_API.G_EXC_ERROR THEN

157: FND_LOG.string(FND_LOG.level_procedure,l_full_name,'End of the API');
158: END IF;
159:
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,

Line 163: x_return_status := FND_API.G_RET_STS_ERROR;

159:
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:

Line 166: p_encoded => fnd_api.g_false);

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
169: Rollback to Insert_Rule_Pub;
170: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;

Line 168: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN

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
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,

Line 170: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;

166: p_encoded => fnd_api.g_false);
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:

Line 173: p_encoded => fnd_api.g_false);

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
176: Rollback to Insert_Rule_Pub;
177: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;

Line 177: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;

173: p_encoded => fnd_api.g_false);
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,

Line 183: p_encoded => FND_API.G_FALSE);

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;
186:
187: ------------------------------------------------------------------------------------

Line 203: p_init_msg_list IN VARCHAR2 := FND_API.G_FALSE,

199: -- End of Comments
200:
201: PROCEDURE Update_Rule (
202: p_api_version IN NUMBER,
203: p_init_msg_list IN VARCHAR2 := FND_API.G_FALSE,
204: p_commit IN VARCHAR2 := FND_API.G_FALSE,
205: p_validation_level IN NUMBER := FND_API.G_VALID_LEVEL_FULL,
206: p_module IN VARCHAR2 := 'JSP',
207: p_rule_rec IN AHL_MC_RULE_PVT.Rule_Rec_Type,

Line 204: p_commit IN VARCHAR2 := FND_API.G_FALSE,

200:
201: PROCEDURE Update_Rule (
202: p_api_version IN NUMBER,
203: p_init_msg_list IN VARCHAR2 := FND_API.G_FALSE,
204: p_commit IN VARCHAR2 := FND_API.G_FALSE,
205: p_validation_level IN NUMBER := FND_API.G_VALID_LEVEL_FULL,
206: p_module IN VARCHAR2 := 'JSP',
207: p_rule_rec IN AHL_MC_RULE_PVT.Rule_Rec_Type,
208: p_rule_stmt_tbl IN AHL_MC_RULE_PVT.UI_Rule_Stmt_Tbl_Type,

Line 205: p_validation_level IN NUMBER := FND_API.G_VALID_LEVEL_FULL,

201: PROCEDURE Update_Rule (
202: p_api_version IN NUMBER,
203: p_init_msg_list IN VARCHAR2 := FND_API.G_FALSE,
204: p_commit IN VARCHAR2 := FND_API.G_FALSE,
205: p_validation_level IN NUMBER := FND_API.G_VALID_LEVEL_FULL,
206: p_module IN VARCHAR2 := 'JSP',
207: p_rule_rec IN AHL_MC_RULE_PVT.Rule_Rec_Type,
208: p_rule_stmt_tbl IN AHL_MC_RULE_PVT.UI_Rule_Stmt_Tbl_Type,
209: x_return_status OUT NOCOPY VARCHAR2,

Line 232: x_return_status := FND_API.G_RET_STS_SUCCESS;

228: -- Standard start of API savepoint
229: SAVEPOINT Update_Rule_Pub;
230:
231: -- Initialize Procedure return status to success
232: x_return_status := FND_API.G_RET_STS_SUCCESS;
233:
234: -- Standard call to check for call compatibility
235: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version,
236: l_api_name, G_PKG_NAME) THEN

Line 235: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version,

231: -- Initialize Procedure return status to success
232: x_return_status := FND_API.G_RET_STS_SUCCESS;
233:
234: -- Standard call to check for call compatibility
235: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version,
236: l_api_name, G_PKG_NAME) THEN
237: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
238: END IF;
239:

Line 237: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;

233:
234: -- Standard call to check for call compatibility
235: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version,
236: l_api_name, G_PKG_NAME) THEN
237: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
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

Line 241: IF FND_API.To_Boolean(p_init_msg_list) THEN

237: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
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

Line 260: RAISE FND_API.G_EXC_ERROR;

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
264: Convert_Rule_Values_to_Id(l_rule_rec, 'U');

Line 282: RAISE FND_API.G_EXC_ERROR;

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
286: Convert_Rule_Stmt_Values_to_Id(l_rule_stmt_tbl, 'U');

Line 307: IF (x_return_status <> FND_API.G_RET_STS_SUCCESS) THEN

303: x_msg_data => x_msg_data
304: );
305:
306: -- check for the return status
307: IF (x_return_status <> FND_API.G_RET_STS_SUCCESS) THEN
308: IF (FND_LOG.level_statement >= FND_LOG.g_current_runtime_level) THEN
309: FND_LOG.string(FND_LOG.level_statement,l_full_name,
310: 'Raising exception with x_return_status => '||x_return_status);
311: END IF;

Line 313: RAISE FND_API.G_EXC_ERROR;

309: FND_LOG.string(FND_LOG.level_statement,l_full_name,
310: 'Raising exception with x_return_status => '||x_return_status);
311: END IF;
312:
313: RAISE FND_API.G_EXC_ERROR;
314: END IF;
315:
316: IF (FND_LOG.level_statement >= FND_LOG.g_current_runtime_level) THEN
317: FND_LOG.string(FND_LOG.level_statement,l_full_name,'After call to private API.');

Line 321: IF FND_API.TO_BOOLEAN(p_commit) THEN

317: FND_LOG.string(FND_LOG.level_statement,l_full_name,'After call to private API.');
318: END IF;
319:
320: -- Standard check of p_commit
321: IF FND_API.TO_BOOLEAN(p_commit) THEN
322: COMMIT WORK;
323: END IF;
324:
325: -- Standard call to get message count and if count is 1, get message info

Line 329: p_encoded => FND_API.G_FALSE

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: );
331:
332: IF (FND_LOG.level_procedure >= FND_LOG.g_current_runtime_level) THEN
333: FND_LOG.string(FND_LOG.level_procedure,l_full_name,'End of the API');

Line 337: WHEN FND_API.G_EXC_ERROR THEN

333: FND_LOG.string(FND_LOG.level_procedure,l_full_name,'End of the API');
334: END IF;
335:
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,

Line 339: x_return_status := FND_API.G_RET_STS_ERROR;

335:
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:

Line 342: p_encoded => fnd_api.g_false);

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
345: Rollback to Update_Rule_Pub;
346: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;

Line 344: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN

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
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,

Line 346: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;

342: p_encoded => fnd_api.g_false);
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:

Line 349: p_encoded => fnd_api.g_false);

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
352: Rollback to Update_Rule_Pub;
353: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;

Line 353: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;

349: p_encoded => fnd_api.g_false);
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,

Line 359: p_encoded => FND_API.G_FALSE);

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;
362:
363: ------------------------------------------------------------------------------------

Line 386: p_init_msg_list IN VARCHAR2 := FND_API.G_FALSE,

382: -- End of Comments
383:
384: PROCEDURE Delete_Rule (
385: p_api_version IN NUMBER,
386: p_init_msg_list IN VARCHAR2 := FND_API.G_FALSE,
387: p_commit IN VARCHAR2 := FND_API.G_FALSE,
388: p_validation_level IN NUMBER := FND_API.G_VALID_LEVEL_FULL,
389: p_rule_rec IN AHL_MC_RULE_PVT.Rule_Rec_Type,
390: x_return_status OUT NOCOPY VARCHAR2,

Line 387: p_commit IN VARCHAR2 := FND_API.G_FALSE,

383:
384: PROCEDURE Delete_Rule (
385: p_api_version IN NUMBER,
386: p_init_msg_list IN VARCHAR2 := FND_API.G_FALSE,
387: p_commit IN VARCHAR2 := FND_API.G_FALSE,
388: p_validation_level IN NUMBER := FND_API.G_VALID_LEVEL_FULL,
389: p_rule_rec IN AHL_MC_RULE_PVT.Rule_Rec_Type,
390: x_return_status OUT NOCOPY VARCHAR2,
391: x_msg_count OUT NOCOPY NUMBER,

Line 388: p_validation_level IN NUMBER := FND_API.G_VALID_LEVEL_FULL,

384: PROCEDURE Delete_Rule (
385: p_api_version IN NUMBER,
386: p_init_msg_list IN VARCHAR2 := FND_API.G_FALSE,
387: p_commit IN VARCHAR2 := FND_API.G_FALSE,
388: p_validation_level IN NUMBER := FND_API.G_VALID_LEVEL_FULL,
389: p_rule_rec IN AHL_MC_RULE_PVT.Rule_Rec_Type,
390: x_return_status OUT NOCOPY VARCHAR2,
391: x_msg_count OUT NOCOPY NUMBER,
392: x_msg_data OUT NOCOPY VARCHAR2

Line 412: x_return_status := FND_API.G_RET_STS_SUCCESS;

408: -- Standard start of API savepoint
409: SAVEPOINT Delete_Rule_Pub;
410:
411: -- Initialize Procedure return status to success
412: x_return_status := FND_API.G_RET_STS_SUCCESS;
413:
414: -- Standard call to check for call compatibility
415: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version,
416: l_api_name, G_PKG_NAME) THEN

Line 415: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version,

411: -- Initialize Procedure return status to success
412: x_return_status := FND_API.G_RET_STS_SUCCESS;
413:
414: -- Standard call to check for call compatibility
415: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version,
416: l_api_name, G_PKG_NAME) THEN
417: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
418: END IF;
419:

Line 417: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;

413:
414: -- Standard call to check for call compatibility
415: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version,
416: l_api_name, G_PKG_NAME) THEN
417: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
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

Line 421: IF FND_API.To_Boolean(p_init_msg_list) THEN

417: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
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

Line 439: RAISE FND_API.G_EXC_ERROR;

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
443: Convert_Rule_Values_to_Id(l_rule_rec, 'D');

Line 472: IF (x_return_status <> FND_API.G_RET_STS_SUCCESS) THEN

468: x_msg_data => x_msg_data
469: );
470:
471: -- check for the return status
472: IF (x_return_status <> FND_API.G_RET_STS_SUCCESS) THEN
473: IF (FND_LOG.level_statement >= FND_LOG.g_current_runtime_level) THEN
474: FND_LOG.string(FND_LOG.level_statement,l_full_name,
475: 'Raising exception with x_return_status => '||x_return_status);
476: END IF;

Line 478: RAISE FND_API.G_EXC_ERROR;

474: FND_LOG.string(FND_LOG.level_statement,l_full_name,
475: 'Raising exception with x_return_status => '||x_return_status);
476: END IF;
477:
478: RAISE FND_API.G_EXC_ERROR;
479: END IF;
480:
481: IF (FND_LOG.level_statement >= FND_LOG.g_current_runtime_level) THEN
482: FND_LOG.string(FND_LOG.level_statement,l_full_name,'After call to private API.');

Line 486: IF FND_API.TO_BOOLEAN(p_commit) THEN

482: FND_LOG.string(FND_LOG.level_statement,l_full_name,'After call to private API.');
483: END IF;
484:
485: -- Standard check of p_commit
486: IF FND_API.TO_BOOLEAN(p_commit) THEN
487: COMMIT WORK;
488: END IF;
489:
490: -- Standard call to get message count and if count is 1, get message info

Line 494: p_encoded => FND_API.G_FALSE

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: );
496:
497: IF (FND_LOG.level_procedure >= FND_LOG.g_current_runtime_level) THEN
498: FND_LOG.string(FND_LOG.level_procedure,l_full_name,'End of the API');

Line 502: WHEN FND_API.G_EXC_ERROR THEN

498: FND_LOG.string(FND_LOG.level_procedure,l_full_name,'End of the API');
499: END IF;
500:
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,

Line 504: x_return_status := FND_API.G_RET_STS_ERROR;

500:
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:

Line 507: p_encoded => fnd_api.g_false);

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
510: Rollback to Delete_Rule_Pub;
511: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;

Line 509: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN

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
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,

Line 511: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;

507: p_encoded => fnd_api.g_false);
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:

Line 514: p_encoded => fnd_api.g_false);

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
517: Rollback to Delete_Rule_Pub;
518: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;

Line 518: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;

514: p_encoded => fnd_api.g_false);
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,

Line 524: p_encoded => FND_API.G_FALSE);

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;
527:
528: ------------------------------------------------------------------------------------------

Line 551: p_init_msg_list IN VARCHAR2 := FND_API.G_FALSE,

547: -- End of Comments
548:
549: PROCEDURE Copy_Rules_For_MC (
550: p_api_version IN NUMBER,
551: p_init_msg_list IN VARCHAR2 := FND_API.G_FALSE,
552: p_commit IN VARCHAR2 := FND_API.G_FALSE,
553: p_validation_level IN NUMBER := FND_API.G_VALID_LEVEL_FULL,
554: p_from_mc_header_id IN NUMBER,
555: p_to_mc_header_id IN NUMBER,

Line 552: p_commit IN VARCHAR2 := FND_API.G_FALSE,

548:
549: PROCEDURE Copy_Rules_For_MC (
550: p_api_version IN NUMBER,
551: p_init_msg_list IN VARCHAR2 := FND_API.G_FALSE,
552: p_commit IN VARCHAR2 := FND_API.G_FALSE,
553: p_validation_level IN NUMBER := FND_API.G_VALID_LEVEL_FULL,
554: p_from_mc_header_id IN NUMBER,
555: p_to_mc_header_id IN NUMBER,
556: p_from_mc_name IN VARCHAR2,

Line 553: p_validation_level IN NUMBER := FND_API.G_VALID_LEVEL_FULL,

549: PROCEDURE Copy_Rules_For_MC (
550: p_api_version IN NUMBER,
551: p_init_msg_list IN VARCHAR2 := FND_API.G_FALSE,
552: p_commit IN VARCHAR2 := FND_API.G_FALSE,
553: p_validation_level IN NUMBER := FND_API.G_VALID_LEVEL_FULL,
554: p_from_mc_header_id IN NUMBER,
555: p_to_mc_header_id IN NUMBER,
556: p_from_mc_name IN VARCHAR2,
557: p_from_revision IN VARCHAR2,

Line 594: x_return_status := FND_API.G_RET_STS_SUCCESS;

590: -- Standard start of API savepoint
591: SAVEPOINT Copy_Rules_For_MC_Pub;
592:
593: -- Initialize Procedure return status to success
594: x_return_status := FND_API.G_RET_STS_SUCCESS;
595:
596: -- Standard call to check for call compatibility
597: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version,
598: l_api_name, G_PKG_NAME) THEN

Line 597: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version,

593: -- Initialize Procedure return status to success
594: x_return_status := FND_API.G_RET_STS_SUCCESS;
595:
596: -- Standard call to check for call compatibility
597: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version,
598: l_api_name, G_PKG_NAME) THEN
599: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
600: END IF;
601:

Line 599: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;

595:
596: -- Standard call to check for call compatibility
597: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version,
598: l_api_name, G_PKG_NAME) THEN
599: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
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

Line 603: IF FND_API.To_Boolean(p_init_msg_list) THEN

599: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
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

Line 625: RAISE FND_API.G_EXC_ERROR;

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;
629:

Line 637: RAISE FND_API.G_EXC_ERROR;

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;
641: END IF;

Line 653: RAISE FND_API.G_EXC_ERROR;

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;
657: CLOSE chk_mc_header_id_csr;

Line 667: RAISE FND_API.G_EXC_ERROR;

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;
671:

Line 679: RAISE FND_API.G_EXC_ERROR;

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;
683: END IF;

Line 695: RAISE FND_API.G_EXC_ERROR;

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;
699: CLOSE chk_mc_header_id_csr;

Line 730: IF (x_return_status <> FND_API.G_RET_STS_SUCCESS) THEN

726: x_msg_data => x_msg_data
727: );
728:
729: -- check for the return status
730: IF (x_return_status <> FND_API.G_RET_STS_SUCCESS) THEN
731: IF (FND_LOG.level_statement >= FND_LOG.g_current_runtime_level) THEN
732: FND_LOG.string(FND_LOG.level_statement,l_full_name,
733: 'Raising exception with x_return_status => '||x_return_status);
734: END IF;

Line 736: RAISE FND_API.G_EXC_ERROR;

732: FND_LOG.string(FND_LOG.level_statement,l_full_name,
733: 'Raising exception with x_return_status => '||x_return_status);
734: END IF;
735:
736: RAISE FND_API.G_EXC_ERROR;
737: END IF;
738:
739: IF (FND_LOG.level_statement >= FND_LOG.g_current_runtime_level) THEN
740: FND_LOG.string(FND_LOG.level_statement,l_full_name,'After call to private API.');

Line 744: IF FND_API.TO_BOOLEAN(p_commit) THEN

740: FND_LOG.string(FND_LOG.level_statement,l_full_name,'After call to private API.');
741: END IF;
742:
743: -- Standard check of p_commit
744: IF FND_API.TO_BOOLEAN(p_commit) THEN
745: COMMIT WORK;
746: END IF;
747:
748: -- Standard call to get message count and if count is 1, get message info

Line 752: p_encoded => FND_API.G_FALSE

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: );
754:
755: IF (FND_LOG.level_procedure >= FND_LOG.g_current_runtime_level) THEN
756: FND_LOG.string(FND_LOG.level_procedure,l_full_name,'End of the API');

Line 760: WHEN FND_API.G_EXC_ERROR THEN

756: FND_LOG.string(FND_LOG.level_procedure,l_full_name,'End of the API');
757: END IF;
758:
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,

Line 762: x_return_status := FND_API.G_RET_STS_ERROR;

758:
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:

Line 765: p_encoded => fnd_api.g_false);

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
768: Rollback to Copy_Rules_For_MC_Pub;
769: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;

Line 767: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN

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
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,

Line 769: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;

765: p_encoded => fnd_api.g_false);
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:

Line 772: p_encoded => fnd_api.g_false);

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
775: Rollback to Copy_Rules_For_MC_Pub;
776: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;

Line 776: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;

772: p_encoded => fnd_api.g_false);
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,

Line 782: p_encoded => FND_API.G_FALSE);

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;
785:
786: --------------------------------------------------------------------------------------------

Line 804: p_init_msg_list IN VARCHAR2 := FND_API.G_FALSE,

800: -- End of Comments
801:
802: PROCEDURE Delete_Rules_For_MC (
803: p_api_version IN NUMBER,
804: p_init_msg_list IN VARCHAR2 := FND_API.G_FALSE,
805: p_commit IN VARCHAR2 := FND_API.G_FALSE,
806: p_validation_level IN NUMBER := FND_API.G_VALID_LEVEL_FULL,
807: p_mc_header_id IN NUMBER,
808: p_mc_name IN VARCHAR2,

Line 805: p_commit IN VARCHAR2 := FND_API.G_FALSE,

801:
802: PROCEDURE Delete_Rules_For_MC (
803: p_api_version IN NUMBER,
804: p_init_msg_list IN VARCHAR2 := FND_API.G_FALSE,
805: p_commit IN VARCHAR2 := FND_API.G_FALSE,
806: p_validation_level IN NUMBER := FND_API.G_VALID_LEVEL_FULL,
807: p_mc_header_id IN NUMBER,
808: p_mc_name IN VARCHAR2,
809: p_revision IN VARCHAR2,

Line 806: p_validation_level IN NUMBER := FND_API.G_VALID_LEVEL_FULL,

802: PROCEDURE Delete_Rules_For_MC (
803: p_api_version IN NUMBER,
804: p_init_msg_list IN VARCHAR2 := FND_API.G_FALSE,
805: p_commit IN VARCHAR2 := FND_API.G_FALSE,
806: p_validation_level IN NUMBER := FND_API.G_VALID_LEVEL_FULL,
807: p_mc_header_id IN NUMBER,
808: p_mc_name IN VARCHAR2,
809: p_revision IN VARCHAR2,
810: x_return_status OUT NOCOPY VARCHAR2,

Line 843: x_return_status := FND_API.G_RET_STS_SUCCESS;

839: -- Standard start of API savepoint
840: SAVEPOINT Delete_Rules_For_MC_Pub;
841:
842: -- Initialize Procedure return status to success
843: x_return_status := FND_API.G_RET_STS_SUCCESS;
844:
845: -- Standard call to check for call compatibility
846: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version,
847: l_api_name, G_PKG_NAME) THEN

Line 846: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version,

842: -- Initialize Procedure return status to success
843: x_return_status := FND_API.G_RET_STS_SUCCESS;
844:
845: -- Standard call to check for call compatibility
846: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version,
847: l_api_name, G_PKG_NAME) THEN
848: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
849: END IF;
850:

Line 848: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;

844:
845: -- Standard call to check for call compatibility
846: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version,
847: l_api_name, G_PKG_NAME) THEN
848: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
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

Line 852: IF FND_API.To_Boolean(p_init_msg_list) THEN

848: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
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

Line 870: RAISE FND_API.G_EXC_ERROR;

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;
874:

Line 882: RAISE FND_API.G_EXC_ERROR;

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;
886: END IF;

Line 898: RAISE FND_API.G_EXC_ERROR;

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;
902: CLOSE chk_mc_header_id_csr;

Line 929: IF (x_return_status <> FND_API.G_RET_STS_SUCCESS) THEN

925: x_msg_data => x_msg_data
926: );
927:
928: -- check for the return status
929: IF (x_return_status <> FND_API.G_RET_STS_SUCCESS) THEN
930: IF (FND_LOG.level_statement >= FND_LOG.g_current_runtime_level) THEN
931: FND_LOG.string(FND_LOG.level_statement,l_full_name,
932: 'Raising exception with x_return_status => '||x_return_status);
933: END IF;

Line 935: RAISE FND_API.G_EXC_ERROR;

931: FND_LOG.string(FND_LOG.level_statement,l_full_name,
932: 'Raising exception with x_return_status => '||x_return_status);
933: END IF;
934:
935: RAISE FND_API.G_EXC_ERROR;
936: END IF;
937:
938: IF (FND_LOG.level_statement >= FND_LOG.g_current_runtime_level) THEN
939: FND_LOG.string(FND_LOG.level_statement,l_full_name,'After call to private API.');

Line 943: IF FND_API.TO_BOOLEAN(p_commit) THEN

939: FND_LOG.string(FND_LOG.level_statement,l_full_name,'After call to private API.');
940: END IF;
941:
942: -- Standard check of p_commit
943: IF FND_API.TO_BOOLEAN(p_commit) THEN
944: COMMIT WORK;
945: END IF;
946:
947: -- Standard call to get message count and if count is 1, get message info

Line 951: p_encoded => FND_API.G_FALSE

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: );
953:
954: IF (FND_LOG.level_procedure >= FND_LOG.g_current_runtime_level) THEN
955: FND_LOG.string(FND_LOG.level_procedure,l_full_name,'End of the API');

Line 959: WHEN FND_API.G_EXC_ERROR THEN

955: FND_LOG.string(FND_LOG.level_procedure,l_full_name,'End of the API');
956: END IF;
957:
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,

Line 961: x_return_status := FND_API.G_RET_STS_ERROR;

957:
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:

Line 964: p_encoded => fnd_api.g_false);

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
967: Rollback to Delete_Rules_For_MC_Pub;
968: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;

Line 966: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN

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
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,

Line 968: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;

964: p_encoded => fnd_api.g_false);
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:

Line 971: p_encoded => fnd_api.g_false);

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
974: Rollback to Delete_Rules_For_MC_Pub;
975: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;

Line 975: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;

971: p_encoded => fnd_api.g_false);
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,

Line 981: p_encoded => FND_API.G_FALSE);

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;
984:
985: -----------------------------------------------------------------------------------------------

Line 1007: p_init_msg_list IN VARCHAR2 := FND_API.G_FALSE,

1003: -- End of Comments
1004:
1005: PROCEDURE Get_Rules_For_Position (
1006: p_api_version IN NUMBER,
1007: p_init_msg_list IN VARCHAR2 := FND_API.G_FALSE,
1008: p_commit IN VARCHAR2 := FND_API.G_FALSE,
1009: p_validation_level IN NUMBER := FND_API.G_VALID_LEVEL_FULL,
1010: p_mc_header_id IN NUMBER,
1011: p_encoded_path IN VARCHAR2,

Line 1008: p_commit IN VARCHAR2 := FND_API.G_FALSE,

1004:
1005: PROCEDURE Get_Rules_For_Position (
1006: p_api_version IN NUMBER,
1007: p_init_msg_list IN VARCHAR2 := FND_API.G_FALSE,
1008: p_commit IN VARCHAR2 := FND_API.G_FALSE,
1009: p_validation_level IN NUMBER := FND_API.G_VALID_LEVEL_FULL,
1010: p_mc_header_id IN NUMBER,
1011: p_encoded_path IN VARCHAR2,
1012: p_mc_name IN VARCHAR2,

Line 1009: p_validation_level IN NUMBER := FND_API.G_VALID_LEVEL_FULL,

1005: PROCEDURE Get_Rules_For_Position (
1006: p_api_version IN NUMBER,
1007: p_init_msg_list IN VARCHAR2 := FND_API.G_FALSE,
1008: p_commit IN VARCHAR2 := FND_API.G_FALSE,
1009: p_validation_level IN NUMBER := FND_API.G_VALID_LEVEL_FULL,
1010: p_mc_header_id IN NUMBER,
1011: p_encoded_path IN VARCHAR2,
1012: p_mc_name IN VARCHAR2,
1013: p_revision IN VARCHAR2,

Line 1048: x_return_status := FND_API.G_RET_STS_SUCCESS;

1044: -- Standard start of API savepoint
1045: SAVEPOINT Get_Rules_For_Position_Pub;
1046:
1047: -- Initialize Procedure return status to success
1048: x_return_status := FND_API.G_RET_STS_SUCCESS;
1049:
1050: -- Standard call to check for call compatibility
1051: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version,
1052: l_api_name, G_PKG_NAME) THEN

Line 1051: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version,

1047: -- Initialize Procedure return status to success
1048: x_return_status := FND_API.G_RET_STS_SUCCESS;
1049:
1050: -- Standard call to check for call compatibility
1051: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version,
1052: l_api_name, G_PKG_NAME) THEN
1053: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
1054: END IF;
1055:

Line 1053: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;

1049:
1050: -- Standard call to check for call compatibility
1051: IF NOT FND_API.Compatible_API_Call(l_api_version, p_api_version,
1052: l_api_name, G_PKG_NAME) THEN
1053: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
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

Line 1057: IF FND_API.To_Boolean(p_init_msg_list) THEN

1053: RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
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

Line 1074: RAISE FND_API.G_EXC_ERROR;

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
1078: -- input is NULL

Line 1081: RAISE FND_API.G_EXC_ERROR;

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;
1085:

Line 1093: RAISE FND_API.G_EXC_ERROR;

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;
1097: END IF;

Line 1109: RAISE FND_API.G_EXC_ERROR;

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;
1113: CLOSE chk_mc_header_id_csr;

Line 1143: IF (x_return_status <> FND_API.G_RET_STS_SUCCESS) THEN

1139: x_msg_data => x_msg_data
1140: );
1141:
1142: -- check for the return status
1143: IF (x_return_status <> FND_API.G_RET_STS_SUCCESS) THEN
1144: IF (FND_LOG.level_statement >= FND_LOG.g_current_runtime_level) THEN
1145: FND_LOG.string(FND_LOG.level_statement,l_full_name,
1146: 'Raising exception with x_return_status => '||x_return_status);
1147: END IF;

Line 1149: RAISE FND_API.G_EXC_ERROR;

1145: FND_LOG.string(FND_LOG.level_statement,l_full_name,
1146: 'Raising exception with x_return_status => '||x_return_status);
1147: END IF;
1148:
1149: RAISE FND_API.G_EXC_ERROR;
1150: END IF;
1151:
1152: IF (FND_LOG.level_statement >= FND_LOG.g_current_runtime_level) THEN
1153: FND_LOG.string(FND_LOG.level_statement,l_full_name,'After call to private API.');

Line 1162: IF FND_API.TO_BOOLEAN(p_commit) THEN

1158: ' x_rule_tbl.COUNT => '||x_rule_tbl.COUNT);
1159: END IF;
1160:
1161: -- Standard check of p_commit
1162: IF FND_API.TO_BOOLEAN(p_commit) THEN
1163: COMMIT WORK;
1164: END IF;
1165:
1166: -- Standard call to get message count and if count is 1, get message info

Line 1170: p_encoded => FND_API.G_FALSE

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: );
1172:
1173: IF (FND_LOG.level_procedure >= FND_LOG.g_current_runtime_level) THEN
1174: FND_LOG.string(FND_LOG.level_procedure,l_full_name,'End of the API');

Line 1178: WHEN FND_API.G_EXC_ERROR THEN

1174: FND_LOG.string(FND_LOG.level_procedure,l_full_name,'End of the API');
1175: END IF;
1176:
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,

Line 1180: x_return_status := FND_API.G_RET_STS_ERROR;

1176:
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:

Line 1183: p_encoded => fnd_api.g_false);

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
1186: Rollback to Get_Rules_For_Position_Pub;
1187: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;

Line 1185: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN

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
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,

Line 1187: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;

1183: p_encoded => fnd_api.g_false);
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:

Line 1190: p_encoded => fnd_api.g_false);

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
1193: Rollback to Get_Rules_For_Position_Pub;
1194: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;

Line 1194: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;

1190: p_encoded => fnd_api.g_false);
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,

Line 1200: p_encoded => FND_API.G_FALSE);

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;
1203:
1204: -----------------------------------------------------------------------------------------------

Line 1280: RAISE FND_API.G_EXC_ERROR;

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;
1284:

Line 1292: RAISE FND_API.G_EXC_ERROR;

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
1296: l_rule_rec.mc_header_id := l_mc_header_id;

Line 1310: RAISE FND_API.G_EXC_ERROR;

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;
1314: END IF;

Line 1323: RAISE FND_API.G_EXC_ERROR;

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(
1327: p_lookup_type => 'AHL_MC_RULE_TYPES',

Line 1341: RAISE FND_API.G_EXC_ERROR;

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
1345: -- check with rule_type_code

Line 1355: RAISE FND_API.G_EXC_ERROR;

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;
1359: END IF;

Line 1380: RAISE FND_API.G_EXC_ERROR;

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
1384: l_rule_rec.rule_id := l_rule_id;

Line 1392: RAISE FND_API.G_EXC_ERROR;

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;
1396:

Line 1404: RAISE FND_API.G_EXC_ERROR;

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
1408: l_rule_rec.mc_header_id := l_mc_header_id;

Line 1422: RAISE FND_API.G_EXC_ERROR;

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
1426: l_rule_rec.rule_id := l_rule_id;

Line 1434: RAISE FND_API.G_EXC_ERROR;

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
1438: OPEN chk_rule_id_csr(l_rule_rec.rule_id);

Line 1447: RAISE FND_API.G_EXC_ERROR;

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;
1451: END IF;

Line 1812: RAISE FND_API.G_EXC_ERROR;

1808: END IF;
1809:
1810: -- raise the exception if some error occurred
1811: IF (l_flag = 'Y') THEN
1812: RAISE FND_API.G_EXC_ERROR;
1813: END IF;
1814: END LOOP;
1815:
1816: -- return changed record